@usequark/quark-create-app 1.23.11

package/templates/mobile/lib/api-client.ts

@@ -0,0 +1,138 @@
+import { getConfig } from "./config";
+import { ApiError, type AppClientError } from "./errors";
+import { clearTokens, getRefreshToken, getToken, storeTokens } from "./storage";
+
+interface ApiResponse<T = unknown> {
+	data: T;
+	status: number;
+}
+
+interface FetchOptions extends RequestInit {
+	timeout?: number;
+}
+
+const DEFAULT_TIMEOUT = 15000;
+
+/**
+ * Injects Bearer token from SecureStore, handles 401 with refresh + retry.
+ */
+export async function apiClient<T = unknown>(
+	path: string,
+	options: FetchOptions = {},
+): Promise<ApiResponse<T>> {
+	const { timeout = DEFAULT_TIMEOUT, ...fetchOptions } = options;
+	const config = getConfig();
+
+	const headers = new Headers(fetchOptions.headers);
+	const token = await getToken();
+	if (token) {
+		headers.set("Authorization", `Bearer ${token}`);
+	}
+	if (!headers.has("Content-Type") && fetchOptions.body) {
+		headers.set("Content-Type", "application/json");
+	}
+
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeout);
+
+	try {
+		const response = await fetch(`${config.apiUrl}${path}`, {
+			...fetchOptions,
+			headers,
+			signal: controller.signal,
+		});
+
+		clearTimeout(timer);
+
+		if (response.status === 401 && token) {
+			const refreshed = await attemptTokenRefresh();
+			if (refreshed) {
+				const retryHeaders = new Headers(headers);
+				retryHeaders.set("Authorization", `Bearer ${refreshed}`);
+				const retryResponse = await fetch(`${config.apiUrl}${path}`, {
+					...fetchOptions,
+					headers: retryHeaders,
+					signal: controller.signal,
+				});
+				return parseResponse<T>(retryResponse);
+			}
+			await clearTokens();
+			throw buildError({
+				name: "UnauthorizedError",
+				message: "Session expired",
+				code: "UNAUTHORIZED",
+				statusCode: 401,
+			});
+		}
+
+		return parseResponse<T>(response);
+	} catch (error) {
+		clearTimeout(timer);
+		if (error instanceof ApiError) throw error;
+		if (error instanceof DOMException && error.name === "AbortError") {
+			throw buildError({
+				name: "TimeoutError",
+				message: "Request timed out",
+				code: "TIMEOUT",
+				statusCode: 408,
+			});
+		}
+		throw buildError({
+			name: "NetworkError",
+			message: error instanceof Error ? error.message : "Network error",
+			code: "NETWORK_ERROR",
+			statusCode: 0,
+		});
+	}
+}
+
+async function attemptTokenRefresh(): Promise<string | null> {
+	try {
+		const refreshToken = await getRefreshToken();
+		if (!refreshToken) return null;
+
+		const config = getConfig();
+		const response = await fetch(`${config.apiUrl}/api/auth/refresh`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken }),
+		});
+
+		if (!response.ok) return null;
+
+		const data = await response.json();
+		await storeTokens(data.token, refreshToken);
+		return data.token;
+	} catch {
+		return null;
+	}
+}
+
+async function parseResponse<T>(response: Response): Promise<ApiResponse<T>> {
+	const text = await response.text();
+	let data: unknown;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		data = text;
+	}
+
+	if (!response.ok) {
+		const errorData = data as Partial<AppClientError>;
+		throw buildError({
+			name: errorData.name || "ApiError",
+			message:
+				errorData.message || `Request failed with status ${response.status}`,
+			code: errorData.code || "UNKNOWN_ERROR",
+			statusCode: response.status,
+			details: errorData.details,
+			retryAfter: errorData.retryAfter,
+		});
+	}
+
+	return { data: data as T, status: response.status };
+}
+
+function buildError(params: AppClientError): ApiError {
+	return new ApiError(params);
+}

package/templates/mobile/lib/api.ts

@@ -0,0 +1,83 @@
+import { apiClient } from "./api-client";
+
+/**
+ * Typed API client functions.
+ * JSDoc types used; replace with generated types when OpenAPI spec is available.
+ */
+
+/**
+ * Get the current user's profile.
+ * @returns {Promise<{ id: string, email: string, name: string | null, role: string }>}
+ */
+export async function getProfile() {
+	const { data } = await apiClient("/api/users/me");
+	return data;
+}
+
+/**
+ * Update the current user's profile.
+ * @param {object} updates - Fields to update
+ */
+export async function updateProfile(updates: Record<string, unknown>) {
+	const { data } = await apiClient("/api/users/me", {
+		method: "PATCH",
+		body: JSON.stringify(updates),
+	});
+	return data;
+}
+
+/**
+ * List items with pagination.
+ * @param {object} params - Query parameters
+ */
+export async function listItems(params = {}) {
+	const query = new URLSearchParams(params).toString();
+	const path = query ? `/api/items?${query}` : "/api/items";
+	const { data } = await apiClient(path);
+	return data;
+}
+
+/**
+ * Get a single item by ID.
+ * @param {string} id
+ */
+export async function getItem(id: string) {
+	const { data } = await apiClient(`/api/items/${id}`);
+	return data;
+}
+
+/**
+ * Create a new item.
+ * @param {object} itemData
+ */
+export async function createItem(itemData: Record<string, unknown>) {
+	const { data } = await apiClient("/api/items", {
+		method: "POST",
+		body: JSON.stringify(itemData),
+	});
+	return data;
+}
+
+/**
+ * Update an item.
+ * @param {string} id
+ * @param {object} updates
+ */
+export async function updateItem(id: string, updates: Record<string, unknown>) {
+	const { data } = await apiClient(`/api/items/${id}`, {
+		method: "PATCH",
+		body: JSON.stringify(updates),
+	});
+	return data;
+}
+
+/**
+ * Delete an item.
+ * @param {string} id
+ */
+export async function deleteItem(id: string) {
+	const { data } = await apiClient(`/api/items/${id}`, {
+		method: "DELETE",
+	});
+	return data;
+}

package/templates/mobile/lib/auth-providers-google.ts

@@ -0,0 +1,74 @@
+import {
+	makeRedirectUri,
+	ResponseType,
+	useAuthRequest,
+} from "expo-auth-session";
+import { useEffect } from "react";
+import { getConfig } from "./config";
+import { ApiError } from "./errors";
+import { storeTokens } from "./storage";
+
+interface SocialAuthResponse {
+	token: string;
+	refreshToken: string;
+	expiresAt: string;
+}
+
+const discovery = {
+	authorizationEndpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+	tokenEndpoint: "https://oauth2.googleapis.com/token",
+	revocationEndpoint: "https://oauth2.googleapis.com/revoke",
+};
+
+/**
+ * Hook-based Google Sign-In using expo-auth-session.
+ * Returns the request function and any error.
+ */
+export function useGoogleAuth() {
+	const redirectUri = makeRedirectUri({
+		scheme: "com.myquark.app",
+		path: "google",
+		native: "com.myquark.app://google",
+	});
+
+	const [request, response, promptAsync] = useAuthRequest(
+		{
+			clientId: process.env.EXPO_PUBLIC_GOOGLE_CLIENT_ID || "",
+			redirectUri,
+			responseType: ResponseType.IdToken,
+			scopes: ["openid", "profile", "email"],
+		},
+		discovery,
+	);
+
+	useEffect(() => {
+		if (response?.type === "success") {
+			const { id_token } = response.params;
+			exchangeGoogleToken(id_token).catch(() => {});
+		}
+	}, [response]);
+
+	return { request, promptAsync };
+}
+
+async function exchangeGoogleToken(idToken: string): Promise<void> {
+	const config = getConfig();
+	const response = await fetch(`${config.apiUrl}/api/auth/google`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ idToken }),
+	});
+
+	if (!response.ok) {
+		const error = await response.json().catch(() => null);
+		throw new ApiError({
+			name: "AuthError",
+			message: error?.message || "Google authentication failed",
+			code: "GOOGLE_AUTH_FAILED",
+			statusCode: 401,
+		});
+	}
+
+	const data: SocialAuthResponse = await response.json();
+	await storeTokens(data.token, data.refreshToken);
+}

package/templates/mobile/lib/auth-providers.ts

@@ -0,0 +1,74 @@
+import * as AppleAuthentication from "expo-apple-authentication";
+import * as Crypto from "expo-crypto";
+import { getConfig } from "./config";
+import { ApiError } from "./errors";
+import { storeTokens } from "./storage";
+
+interface SocialAuthResponse {
+	token: string;
+	refreshToken: string;
+	expiresAt: string;
+}
+
+/**
+ * Sign in with Apple.
+ * Gets an identity token from Apple, sends it to the backend,
+ * receives a custom JWT, and stores it.
+ */
+export async function signInWithApple(): Promise<void> {
+	const isAvailable = await AppleAuthentication.isAvailableAsync();
+	if (!isAvailable) {
+		throw new ApiError({
+			name: "AuthError",
+			message: "Apple Sign In is not available on this device",
+			code: "APPLE_UNAVAILABLE",
+			statusCode: 400,
+		});
+	}
+
+	const nonce = Crypto.randomUUID();
+	const digest = await Crypto.digestStringAsync(
+		Crypto.CryptoDigestAlgorithm.SHA256,
+		nonce,
+	);
+
+	const credential = await AppleAuthentication.signInAsync({
+		requestedScopes: [
+			AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+			AppleAuthentication.AppleAuthenticationScope.EMAIL,
+		],
+		nonce: digest,
+	});
+
+	if (!credential.identityToken) {
+		throw new ApiError({
+			name: "AuthError",
+			message: "Apple Sign In failed: no identity token received",
+			code: "APPLE_NO_TOKEN",
+			statusCode: 400,
+		});
+	}
+
+	const config = getConfig();
+	const response = await fetch(`${config.apiUrl}/api/auth/apple`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			identityToken: credential.identityToken,
+			nonce,
+		}),
+	});
+
+	if (!response.ok) {
+		const error = await response.json().catch(() => null);
+		throw new ApiError({
+			name: "AuthError",
+			message: error?.message || "Apple authentication failed",
+			code: "APPLE_AUTH_FAILED",
+			statusCode: 401,
+		});
+	}
+
+	const data: SocialAuthResponse = await response.json();
+	await storeTokens(data.token, data.refreshToken);
+}

package/templates/mobile/lib/auth.ts

@@ -0,0 +1,100 @@
+import { apiClient } from "./api-client";
+import { getConfig } from "./config";
+import { ApiError } from "./errors";
+import { clearTokens, getToken, storeTokens } from "./storage";
+
+interface TokenResponse {
+	token: string;
+	refreshToken: string;
+	expiresAt: string;
+}
+
+interface RefreshResponse {
+	token: string;
+}
+
+interface UserProfile {
+	id: string;
+	email: string;
+	name: string | null;
+	role: string;
+}
+
+export async function signIn(email: string, password: string): Promise<void> {
+	const config = getConfig();
+	const response = await fetch(`${config.apiUrl}/api/auth/token`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ email, password }),
+	});
+
+	if (!response.ok) {
+		const error = await response.json().catch(() => null);
+		throw new ApiError({
+			name: "AuthError",
+			message: error?.message || "Invalid credentials",
+			code: "INVALID_CREDENTIALS",
+			statusCode: 401,
+		});
+	}
+
+	const data: TokenResponse = await response.json();
+	await storeTokens(data.token, data.refreshToken);
+}
+
+export async function signOut(): Promise<void> {
+	await clearTokens();
+}
+
+export async function refreshToken(): Promise<string> {
+	const { getRefreshToken } = await import("./storage");
+	const refreshTokenValue = await getRefreshToken();
+	if (!refreshTokenValue)
+		throw new ApiError({
+			name: "AuthError",
+			message: "No refresh token available",
+			code: "NO_REFRESH_TOKEN",
+			statusCode: 401,
+		});
+
+	const config = getConfig();
+	const response = await fetch(`${config.apiUrl}/api/auth/refresh`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ refreshToken: refreshTokenValue }),
+	});
+
+	if (!response.ok) {
+		await clearTokens();
+		throw new ApiError({
+			name: "AuthError",
+			message: "Token refresh failed",
+			code: "TOKEN_REFRESH_FAILED",
+			statusCode: 401,
+		});
+	}
+
+	const data: RefreshResponse = await response.json();
+	await storeTokens(data.token, refreshTokenValue);
+	return data.token;
+}
+
+export async function isAuthenticated(): Promise<boolean> {
+	const token = await getToken();
+	return token !== null;
+}
+
+export async function getProfile(): Promise<UserProfile> {
+	const { data } = await apiClient<UserProfile>("/api/users/me");
+	return data;
+}
+
+export async function updateProfile(
+	updates: Partial<Pick<UserProfile, "name">>,
+): Promise<UserProfile> {
+	const { data } = await apiClient<UserProfile>("/api/users/me", {
+		method: "PATCH",
+		body: JSON.stringify(updates),
+	});
+	return data;
+}

package/templates/mobile/lib/config.ts

@@ -0,0 +1,14 @@
+import { ApiError } from "./errors";
+
+export function getConfig() {
+	const apiUrl = process.env.EXPO_PUBLIC_API_URL;
+	if (!apiUrl) {
+		throw new ApiError({
+			name: "ConfigError",
+			message: "EXPO_PUBLIC_API_URL is not set. Add it to your .env file.",
+			code: "MISSING_CONFIG",
+			statusCode: 500,
+		});
+	}
+	return { apiUrl };
+}

package/templates/mobile/lib/errors.ts

@@ -0,0 +1,46 @@
+/**
+ * Mobile equivalent of @techstream/quark-core's AppError.
+ *
+ * React Native cannot import Node.js packages, so this module defines a
+ * client-side error class whose shape mirrors AppError.toJSON() — same
+ * fields (code, statusCode, details) — so the web API's error responses
+ * are consumed identically. Keep the two in sync if adding new fields.
+ */
+export interface AppClientError {
+	name: string;
+	message: string;
+	code: string;
+	statusCode: number;
+	timestamp?: string;
+	details?: unknown;
+	retryAfter?: number;
+}
+
+export class ApiError extends Error {
+	code: string;
+	statusCode: number;
+	details?: unknown;
+
+	constructor(error: AppClientError) {
+		super(error.message);
+		this.name = error.name;
+		this.code = error.code;
+		this.statusCode = error.statusCode;
+		this.details = error.details;
+	}
+}
+
+/**
+ * Pattern-match on error codes for conditional handling.
+ */
+export function isValidationError(error: unknown): error is ApiError {
+	return error instanceof ApiError && error.code === "VALIDATION_ERROR";
+}
+
+export function isUnauthorizedError(error: unknown): error is ApiError {
+	return error instanceof ApiError && error.code === "UNAUTHORIZED";
+}
+
+export function isRateLimitError(error: unknown): error is ApiError {
+	return error instanceof ApiError && error.code === "RATE_LIMIT";
+}

package/templates/mobile/lib/notifications.ts

@@ -0,0 +1,77 @@
+import { Platform } from "react-native";
+import { apiClient } from "./api-client";
+
+/**
+ * Register the device push token with the backend.
+ * Must be called after authentication.
+ */
+export async function registerForPushNotifications(): Promise<string | null> {
+	const Device = await import("expo-device");
+	if (!Device.isDevice) {
+		return null;
+	}
+
+	const Notifications = await import("expo-notifications");
+
+	const { status: existingStatus } = await Notifications.getPermissionsAsync();
+	let finalStatus = existingStatus;
+
+	if (existingStatus !== "granted") {
+		const { status } = await Notifications.requestPermissionsAsync();
+		finalStatus = status;
+	}
+
+	if (finalStatus !== "granted") {
+		return null;
+	}
+
+	const tokenData = await Notifications.getExpoPushTokenAsync();
+	const pushToken = tokenData.data;
+
+	if (Platform.OS === "android") {
+		Notifications.setNotificationChannelAsync("default", {
+			name: "default",
+			importance: Notifications.AndroidImportance.MAX,
+			vibrationPattern: [0, 250, 250, 250],
+			lightColor: "#FF231F7C",
+		});
+	}
+
+	return pushToken;
+}
+
+/**
+ * Send the push token to the backend for storage.
+ */
+export async function registerDevice(pushToken: string): Promise<void> {
+	const { Platform: PlatformModule } = await import("react-native");
+	const Constants = await import("expo-constants");
+	const deviceId =
+		Constants.default?.installationId ||
+		Constants.default?.expoConfig?.extra?.eas?.projectId ||
+		"unknown";
+
+	await apiClient("/api/device/register", {
+		method: "POST",
+		body: JSON.stringify({
+			platform: PlatformModule.OS,
+			pushToken,
+			deviceId,
+		}),
+	});
+}
+
+/**
+ * Configure foreground notification handling.
+ */
+export async function configureNotificationHandler() {
+	const Notifications = await import("expo-notifications");
+	Notifications.setNotificationHandler({
+		handleNotification: async () => ({
+			shouldShowBanner: true,
+			shouldShowList: true,
+			shouldPlaySound: true,
+			shouldSetBadge: false,
+		}),
+	});
+}

package/templates/mobile/lib/storage.ts

@@ -0,0 +1,25 @@
+import * as SecureStore from "expo-secure-store";
+
+const TOKEN_KEY = "auth_token";
+const REFRESH_TOKEN_KEY = "auth_refresh_token";
+
+export async function storeTokens(
+	token: string,
+	refreshToken: string,
+): Promise<void> {
+	await SecureStore.setItemAsync(TOKEN_KEY, token);
+	await SecureStore.setItemAsync(REFRESH_TOKEN_KEY, refreshToken);
+}
+
+export async function getToken(): Promise<string | null> {
+	return SecureStore.getItemAsync(TOKEN_KEY);
+}
+
+export async function getRefreshToken(): Promise<string | null> {
+	return SecureStore.getItemAsync(REFRESH_TOKEN_KEY);
+}
+
+export async function clearTokens(): Promise<void> {
+	await SecureStore.deleteItemAsync(TOKEN_KEY);
+	await SecureStore.deleteItemAsync(REFRESH_TOKEN_KEY);
+}

package/templates/mobile/lib/theme-tokens.ts

@@ -0,0 +1,16 @@
+import { useTheme } from "../components/ThemeProvider";
+
+export function useThemeTokens() {
+	const theme = useTheme();
+	const isDark = theme === "dark";
+
+	return {
+		isDark,
+		bgColor: isDark ? "#000" : "#fff",
+		textColor: isDark ? "#fff" : "#000",
+		mutedColor: isDark ? "#888" : "#666",
+		cardBg: isDark ? "#1c1c1e" : "#f2f2f7",
+		borderColor: isDark ? "#38383a" : "#e5e5ea",
+		inputBg: isDark ? "#2c2c2e" : "#fff",
+	};
+}

package/templates/mobile/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@myquark/mobile",
+	"version": "0.1.0",
+	"main": "expo-router/entry",
+	"scripts": {
+		"dev": "CI=1 expo start",
+		"start": "expo start",
+		"android": "expo start --android",
+		"ios": "expo start --ios",
+		"web": "expo start --web",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"dependencies": {
+		"@expo/vector-icons": "^15.1.1",
+		"expo": "~57.0.25",
+		"expo-apple-authentication": "~57.0.2",
+		"expo-auth-session": "~57.0.13",
+		"expo-constants": "~57.0.19",
+		"expo-crypto": "~57.0.3",
+		"expo-device": "~57.0.2",
+		"expo-notifications": "~57.0.21",
+		"expo-router": "~57.0.23",
+		"expo-secure-store": "~57.0.4",
+		"expo-status-bar": "~57.0.1",
+		"expo-updates": "~57.0.23",
+		"react": "19.3.0",
+		"react-native": "0.87.1",
+		"react-native-safe-area-context": "~5.10.0",
+		"react-native-screens": "~4.28.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.14",
+		"@types/react": "~19.3.0",
+		"typescript": "~7.0.2"
+	}
+}

package/templates/mobile/tsconfig.json

@@ -0,0 +1,10 @@
+{
+	"extends": "expo/tsconfig.base",
+	"compilerOptions": {
+		"strict": true,
+		"paths": {
+			"@/*": ["./*"]
+		}
+	},
+	"include": ["**/*.ts", "**/*.tsx"]
+}