@pylonsync/create-pylon 0.3.53 → 0.3.54

package/templates/backend/consumer/apps/api/functions/upsertProfile.ts

@@ -0,0 +1,70 @@
+import { mutation, v } from "@pylonsync/functions";
+
+/**
+ * Create-or-update the caller's Profile. Handle is unique (case-
+ * insensitive); we lowercase + check before inserting. On update
+ * we don't re-check the handle if it didn't change.
+ */
+export default mutation({
+	args: {
+		handle: v.string(),
+		displayName: v.string(),
+		bio: v.string(),
+	},
+	async handler(
+		ctx,
+		args: { handle: string; displayName: string; bio: string },
+	) {
+		if (!ctx.auth.userId) {
+			throw ctx.error("UNAUTHENTICATED", "log in first");
+		}
+		const handle = args.handle.trim().toLowerCase();
+		if (!/^[a-z0-9_]{2,20}$/.test(handle)) {
+			throw ctx.error(
+				"INVALID_HANDLE",
+				"handle must be 2–20 chars: lowercase letters, digits, underscore",
+			);
+		}
+		const displayName = args.displayName.trim();
+		if (!displayName) {
+			throw ctx.error("EMPTY_NAME", "displayName cannot be empty");
+		}
+
+		const existing = (await ctx.db.query("Profile", {
+			userId: ctx.auth.userId,
+		})) as any[];
+
+		if (existing.length === 0) {
+			// New profile — handle must be unique
+			const dup = (await ctx.db.query("Profile", { handle })) as any[];
+			if (dup.length > 0) {
+				throw ctx.error("HANDLE_TAKEN", `@${handle} is taken`);
+			}
+			const id = await ctx.db.insert("Profile", {
+				userId: ctx.auth.userId,
+				handle,
+				displayName,
+				bio: args.bio.trim() || null,
+				createdAt: new Date().toISOString(),
+			});
+			return await ctx.db.get("Profile", id);
+		}
+
+		const profile = existing[0];
+		// Update — re-check handle uniqueness only if changing
+		if (profile.handle !== handle) {
+			const dup = ((await ctx.db.query("Profile", { handle })) as any[]).filter(
+				(p) => p.id !== profile.id,
+			);
+			if (dup.length > 0) {
+				throw ctx.error("HANDLE_TAKEN", `@${handle} is taken`);
+			}
+		}
+		await ctx.db.update("Profile", profile.id, {
+			handle,
+			displayName,
+			bio: args.bio.trim() || null,
+		});
+		return await ctx.db.get("Profile", profile.id);
+	},
+});

package/templates/backend/consumer/apps/api/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@__APP_NAME_KEBAB__/api",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "pylon dev schema.ts --port 4321",
+    "build": "pylon codegen schema.ts --out pylon.manifest.json && pylon codegen client pylon.manifest.json --out pylon.client.ts",
+    "schema:push": "pylon schema push pylon.manifest.json --sqlite dev.db",
+    "schema:inspect": "pylon schema inspect --sqlite dev.db"
+  },
+  "dependencies": {
+    "@pylonsync/sdk": "^__PYLON_VERSION__",
+    "@pylonsync/functions": "^__PYLON_VERSION__"
+  },
+  "devDependencies": {
+    "@pylonsync/cli": "^__PYLON_VERSION__",
+    "typescript": "^5.5.0"
+  }
+}

package/templates/backend/consumer/apps/api/schema.ts

@@ -0,0 +1,130 @@
+import {
+	entity,
+	field,
+	query,
+	action,
+	policy,
+	buildManifest,
+} from "@pylonsync/sdk";
+
+// ---------------------------------------------------------------------------
+// Consumer feed schema. The shape:
+//
+//   Profile  — public-facing card per User. Handle, display name, bio.
+//   Post     — one row per post. authorId references the Profile that
+//              created it; body holds the text.
+//   Like     — pivot row: which Profile liked which Post. Composite
+//              uniqueness enforced via the ordering of inserts (one
+//              row per (profileId, postId) pair).
+//
+// Reads are wide-open by design — feeds are public. Writes require
+// the caller to own the Profile in question (auth.userId == profileId
+// for Profile updates; auth.userId must own a Profile to post).
+// ---------------------------------------------------------------------------
+
+const Profile = entity("Profile", {
+	userId: field.id("User"),
+	handle: field.string(),
+	displayName: field.string(),
+	bio: field.string().optional(),
+	createdAt: field.datetime(),
+});
+
+const Post = entity("Post", {
+	authorId: field.id("Profile"),
+	body: field.string(),
+	createdAt: field.datetime(),
+});
+
+const Like = entity("Like", {
+	profileId: field.id("Profile"),
+	postId: field.id("Post"),
+	createdAt: field.datetime(),
+});
+
+// ---------------------------------------------------------------------------
+// Function declarations
+// ---------------------------------------------------------------------------
+
+const myProfile = query("myProfile");
+const feed = query("feed");
+const profilePosts = query("profilePosts");
+
+const upsertProfile = action("upsertProfile", {
+	input: [
+		{ name: "handle", type: "string" },
+		{ name: "displayName", type: "string" },
+		{ name: "bio", type: "string" },
+	],
+});
+
+const createPost = action("createPost", {
+	input: [{ name: "body", type: "string" }],
+});
+
+const deletePost = action("deletePost", {
+	input: [{ name: "id", type: "id(Post)" }],
+});
+
+const toggleLike = action("toggleLike", {
+	input: [{ name: "postId", type: "id(Post)" }],
+});
+
+// ---------------------------------------------------------------------------
+// Policies — public reads, owner-only writes.
+// ---------------------------------------------------------------------------
+
+const profilePolicy = policy({
+	name: "profile_public",
+	entity: "Profile",
+	allowRead: "true",
+	allowInsert: "auth.userId == data.userId",
+	allowUpdate: "auth.userId == data.userId",
+	allowDelete: "auth.userId == data.userId",
+});
+
+const postPolicy = policy({
+	name: "post_public",
+	entity: "Post",
+	allowRead: "true",
+	// Caller must own a Profile that's being claimed as the author.
+	allowInsert:
+		"exists(Profile where id = data.authorId and userId = auth.userId)",
+	allowUpdate:
+		"exists(Profile where id = data.authorId and userId = auth.userId)",
+	allowDelete:
+		"exists(Profile where id = data.authorId and userId = auth.userId)",
+});
+
+const likePolicy = policy({
+	name: "like_public",
+	entity: "Like",
+	allowRead: "true",
+	// Caller must own the Profile doing the liking.
+	allowInsert:
+		"exists(Profile where id = data.profileId and userId = auth.userId)",
+	allowUpdate: "false",
+	allowDelete:
+		"exists(Profile where id = data.profileId and userId = auth.userId)",
+});
+
+// ---------------------------------------------------------------------------
+// Manifest
+// ---------------------------------------------------------------------------
+
+const manifest = buildManifest({
+	name: "__APP_NAME_SNAKE__",
+	version: "0.0.1",
+	entities: [Profile, Post, Like],
+	queries: [myProfile, feed, profilePosts],
+	actions: [
+		upsertProfile,
+		createPost,
+		deletePost,
+		toggleLike,
+	],
+	policies: [profilePolicy, postPolicy, likePolicy],
+	routes: [],
+});
+
+console.log(JSON.stringify(manifest));

package/templates/backend/consumer/apps/api/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["schema.ts", "functions/**/*.ts"]
+}

package/templates/expo/chat/apps/expo/App.tsx

@@ -0,0 +1,414 @@
+import { useEffect, useRef, useState } from "react";
+import {
+	View,
+	Text,
+	TextInput,
+	Pressable,
+	FlatList,
+	ActivityIndicator,
+	StyleSheet,
+	Platform,
+	Alert,
+	KeyboardAvoidingView,
+	SafeAreaView,
+} from "react-native";
+import { StatusBar } from "expo-status-bar";
+import { init, callFn } from "@pylonsync/react-native";
+
+const PYLON_BASE_URL =
+	process.env.EXPO_PUBLIC_PYLON_BASE_URL ??
+	(Platform.OS === "android" ? "http://10.0.2.2:4321" : "http://localhost:4321");
+
+type Room = {
+	id: string;
+	slug: string;
+	name: string;
+	createdAt: string;
+};
+
+type Message = {
+	id: string;
+	roomId: string;
+	authorId: string;
+	authorName: string;
+	body: string;
+	createdAt: string;
+};
+
+let initPromise: Promise<void> | null = null;
+function ensureInit() {
+	if (!initPromise) {
+		initPromise = init({
+			baseUrl: PYLON_BASE_URL,
+			appName: "__APP_NAME_SNAKE__",
+		});
+	}
+	return initPromise;
+}
+
+export default function App() {
+	const [ready, setReady] = useState(false);
+	const [rooms, setRooms] = useState<Room[]>([]);
+	const [active, setActive] = useState<Room | null>(null);
+	const [authorName, setAuthorName] = useState("anonymous");
+
+	useEffect(() => {
+		ensureInit().then(async () => {
+			try {
+				const list = await callFn<Room[]>("listRooms", {});
+				setRooms(list);
+				setActive(list[0] ?? null);
+			} catch (e) {
+				Alert.alert("Load failed", String(e));
+			}
+			setReady(true);
+		});
+	}, []);
+
+	if (!ready) {
+		return (
+			<View style={[styles.screen, styles.center]}>
+				<ActivityIndicator />
+			</View>
+		);
+	}
+
+	if (!active) {
+		return (
+			<RoomCreate
+				authorName={authorName}
+				onAuthorNameChange={setAuthorName}
+				onCreated={(r) => {
+					setRooms((prev) => [...prev, r]);
+					setActive(r);
+				}}
+			/>
+		);
+	}
+
+	return (
+		<RoomView
+			room={active}
+			rooms={rooms}
+			onSwitch={setActive}
+			authorName={authorName}
+			onAuthorNameChange={setAuthorName}
+			onCreate={(r) => {
+				setRooms((prev) => [...prev, r]);
+				setActive(r);
+			}}
+		/>
+	);
+}
+
+function RoomCreate({
+	authorName,
+	onAuthorNameChange,
+	onCreated,
+}: {
+	authorName: string;
+	onAuthorNameChange: (s: string) => void;
+	onCreated: (r: Room) => void;
+}) {
+	const [name, setName] = useState("General");
+	const [slug, setSlug] = useState("general");
+	const [creating, setCreating] = useState(false);
+
+	async function create() {
+		setCreating(true);
+		try {
+			const r = await callFn<Room>("createRoom", {
+				slug: slug.toLowerCase(),
+				name,
+			});
+			onCreated(r);
+		} catch (e) {
+			Alert.alert("Create failed", String(e));
+		} finally {
+			setCreating(false);
+		}
+	}
+
+	return (
+		<SafeAreaView style={styles.screen}>
+			<StatusBar style="auto" />
+			<View style={styles.content}>
+				<Text style={styles.title}>__APP_NAME__</Text>
+				<Text style={styles.subtitle}>No rooms yet — create one.</Text>
+				<TextInput
+					style={styles.input}
+					placeholder="Your display name"
+					value={authorName}
+					onChangeText={onAuthorNameChange}
+				/>
+				<TextInput
+					style={styles.input}
+					placeholder="Room name"
+					value={name}
+					onChangeText={setName}
+				/>
+				<TextInput
+					style={styles.input}
+					placeholder="Slug"
+					value={slug}
+					onChangeText={(s) => setSlug(s.toLowerCase())}
+					autoCapitalize="none"
+					autoCorrect={false}
+				/>
+				<Pressable
+					onPress={create}
+					disabled={creating || !name.trim() || !slug.trim()}
+					style={({ pressed }) => [
+						styles.button,
+						(creating || !name.trim() || !slug.trim()) && styles.buttonDisabled,
+						pressed && styles.buttonPressed,
+					]}
+				>
+					<Text style={styles.buttonLabel}>
+						{creating ? "Creating…" : "Create room"}
+					</Text>
+				</Pressable>
+			</View>
+		</SafeAreaView>
+	);
+}
+
+function RoomView({
+	room,
+	rooms,
+	onSwitch,
+	authorName,
+	onAuthorNameChange,
+	onCreate,
+}: {
+	room: Room;
+	rooms: Room[];
+	onSwitch: (r: Room) => void;
+	authorName: string;
+	onAuthorNameChange: (s: string) => void;
+	onCreate: (r: Room) => void;
+}) {
+	const [messages, setMessages] = useState<Message[]>([]);
+	const [draft, setDraft] = useState("");
+	const [sending, setSending] = useState(false);
+	const listRef = useRef<FlatList<Message>>(null);
+
+	useEffect(() => {
+		void load();
+		const t = setInterval(load, 1500);
+		return () => clearInterval(t);
+		async function load() {
+			try {
+				const m = await callFn<Message[]>("roomMessages", { roomId: room.id });
+				setMessages(m);
+			} catch {
+				// ignore — will retry on next tick
+			}
+		}
+	}, [room.id]);
+
+	useEffect(() => {
+		if (messages.length > 0) {
+			listRef.current?.scrollToEnd({ animated: true });
+		}
+	}, [messages.length]);
+
+	async function send() {
+		const body = draft.trim();
+		if (!body) return;
+		setSending(true);
+		setDraft("");
+		try {
+			const msg = await callFn<Message>("sendMessage", {
+				roomId: room.id,
+				body,
+				authorName,
+			});
+			setMessages((prev) => [...prev, msg]);
+		} catch (e) {
+			setDraft(body);
+			Alert.alert("Send failed", String(e));
+		} finally {
+			setSending(false);
+		}
+	}
+
+	async function createRoom() {
+		const name = window?.prompt?.("Room name?") ?? null;
+		if (!name) return;
+		const slug = name
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/g, "-")
+			.replace(/^-|-$/g, "");
+		try {
+			const r = await callFn<Room>("createRoom", { slug, name });
+			onCreate(r);
+		} catch (e) {
+			Alert.alert("Create failed", String(e));
+		}
+	}
+
+	return (
+		<SafeAreaView style={styles.screen}>
+			<StatusBar style="auto" />
+			<KeyboardAvoidingView
+				style={styles.flex}
+				behavior={Platform.OS === "ios" ? "padding" : undefined}
+				keyboardVerticalOffset={64}
+			>
+				<View style={styles.header}>
+					<View>
+						<Text style={styles.title}>{room.name}</Text>
+						<Text style={styles.handle}>#{room.slug}</Text>
+					</View>
+					{rooms.length > 1 && (
+						<Pressable
+							onPress={() => {
+								// Cycle to next room — simplest "switch room" UX without a sidebar.
+								const idx = rooms.findIndex((r) => r.id === room.id);
+								onSwitch(rooms[(idx + 1) % rooms.length]);
+							}}
+						>
+							<Text style={styles.switchBtn}>Next room →</Text>
+						</Pressable>
+					)}
+				</View>
+
+				<View style={styles.namebar}>
+					<Text style={styles.namelabel}>You:</Text>
+					<TextInput
+						style={styles.nameinput}
+						value={authorName}
+						onChangeText={onAuthorNameChange}
+						autoCapitalize="none"
+					/>
+				</View>
+
+				<FlatList
+					ref={listRef}
+					data={messages}
+					keyExtractor={(m) => m.id}
+					contentContainerStyle={{ padding: 16 }}
+					ListEmptyComponent={() => (
+						<Text style={styles.empty}>No messages yet. Say hi.</Text>
+					)}
+					renderItem={({ item }) => (
+						<View style={styles.msg}>
+							<View style={styles.msgHead}>
+								<Text style={styles.msgName}>{item.authorName}</Text>
+								<Text style={styles.msgTime}>
+									{new Date(item.createdAt).toLocaleTimeString(undefined, {
+										hour: "numeric",
+										minute: "2-digit",
+									})}
+								</Text>
+							</View>
+							<Text style={styles.msgBody}>{item.body}</Text>
+						</View>
+					)}
+				/>
+
+				<View style={styles.composer}>
+					<TextInput
+						style={styles.composerInput}
+						value={draft}
+						onChangeText={setDraft}
+						placeholder={`Message ${room.name}…`}
+						multiline
+						editable={!sending}
+					/>
+					<Pressable
+						onPress={send}
+						disabled={sending || !draft.trim()}
+						style={({ pressed }) => [
+							styles.button,
+							(sending || !draft.trim()) && styles.buttonDisabled,
+							pressed && styles.buttonPressed,
+						]}
+					>
+						<Text style={styles.buttonLabel}>Send</Text>
+					</Pressable>
+				</View>
+			</KeyboardAvoidingView>
+		</SafeAreaView>
+	);
+}
+
+const styles = StyleSheet.create({
+	screen: { flex: 1, backgroundColor: "#fff" },
+	flex: { flex: 1 },
+	center: { alignItems: "center", justifyContent: "center" },
+	content: { padding: 20, gap: 12 },
+	title: { fontSize: 24, fontWeight: "600" },
+	subtitle: { color: "#666" },
+	handle: { fontFamily: "Menlo", fontSize: 12, color: "#999" },
+	header: {
+		paddingHorizontal: 20,
+		paddingTop: 12,
+		paddingBottom: 8,
+		flexDirection: "row",
+		justifyContent: "space-between",
+		alignItems: "flex-end",
+		borderBottomWidth: 1,
+		borderColor: "#e5e5e5",
+	},
+	switchBtn: { color: "#3b82f6", fontSize: 13 },
+	namebar: {
+		flexDirection: "row",
+		alignItems: "center",
+		gap: 6,
+		paddingHorizontal: 20,
+		paddingVertical: 6,
+		backgroundColor: "#fafafa",
+	},
+	namelabel: { fontSize: 12, color: "#666" },
+	nameinput: {
+		flex: 1,
+		borderBottomWidth: 1,
+		borderColor: "#d4d4d8",
+		fontSize: 13,
+		paddingVertical: 2,
+	},
+	input: {
+		borderWidth: 1,
+		borderColor: "#d4d4d8",
+		borderRadius: 6,
+		paddingHorizontal: 12,
+		paddingVertical: 8,
+		fontSize: 14,
+	},
+	button: {
+		backgroundColor: "#171717",
+		borderRadius: 6,
+		paddingHorizontal: 16,
+		paddingVertical: 12,
+		alignItems: "center",
+	},
+	buttonDisabled: { opacity: 0.5 },
+	buttonPressed: { opacity: 0.8 },
+	buttonLabel: { color: "#fff", fontWeight: "600", fontSize: 13 },
+	empty: { textAlign: "center", color: "#999", marginTop: 32 },
+	msg: { marginBottom: 16 },
+	msgHead: { flexDirection: "row", alignItems: "baseline", gap: 6 },
+	msgName: { fontSize: 13, fontWeight: "500" },
+	msgTime: { fontSize: 11, color: "#999" },
+	msgBody: { fontSize: 14, marginTop: 2 },
+	composer: {
+		flexDirection: "row",
+		gap: 8,
+		padding: 12,
+		borderTopWidth: 1,
+		borderColor: "#e5e5e5",
+	},
+	composerInput: {
+		flex: 1,
+		minHeight: 36,
+		maxHeight: 120,
+		borderWidth: 1,
+		borderColor: "#d4d4d8",
+		borderRadius: 6,
+		paddingHorizontal: 12,
+		paddingVertical: 8,
+		fontSize: 14,
+	},
+});

package/templates/expo/chat/apps/expo/app.json

@@ -0,0 +1,25 @@
+{
+  "expo": {
+    "name": "__APP_NAME__",
+    "slug": "__APP_NAME_KEBAB__",
+    "version": "0.0.1",
+    "orientation": "portrait",
+    "userInterfaceStyle": "automatic",
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.example.__APP_NAME_SNAKE__",
+      "infoPlist": {
+        "NSAppTransportSecurity": {
+          "NSAllowsLocalNetworking": true
+        }
+      }
+    },
+    "android": {
+      "package": "com.example.__APP_NAME_SNAKE__",
+      "usesCleartextTraffic": true
+    },
+    "web": {
+      "bundler": "metro"
+    }
+  }
+}

package/templates/expo/chat/apps/expo/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = function (api) {
+	api.cache(true);
+	return {
+		presets: ["babel-preset-expo"],
+	};
+};

package/templates/expo/chat/apps/expo/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@__APP_NAME_KEBAB__/expo",
+  "version": "0.0.1",
+  "private": true,
+  "main": "node_modules/expo/AppEntry.js",
+  "scripts": {
+    "start": "expo start",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web"
+  },
+  "dependencies": {
+    "@pylonsync/sdk": "^__PYLON_VERSION__",
+    "@pylonsync/react": "^__PYLON_VERSION__",
+    "@pylonsync/react-native": "^__PYLON_VERSION__",
+    "@pylonsync/sync": "^__PYLON_VERSION__",
+    "@react-native-async-storage/async-storage": "1.23.1",
+    "@react-native-community/netinfo": "11.3.1",
+    "expo": "~51.0.0",
+    "expo-status-bar": "~1.12.1",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
+    "react-native": "0.74.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.20.0",
+    "@types/react": "^19.0.0",
+    "typescript": "^5.5.0"
+  }
+}