create-better-t-stack 3.11.0 → 3.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.11.0",
+  "version": "3.12.0",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -67,7 +67,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-t-stack/types": "^3.11.0",
+    "@better-t-stack/types": "^3.12.0",
     "@clack/prompts": "^1.0.0-alpha.8",
     "@orpc/server": "^1.13.0",
     "consola": "^3.4.2",

package/templates/addons/turborepo/turbo.json.hbs

@@ -55,6 +55,19 @@
 		"db:down": {
 			"cache": false,
 			"persistent": true
+		}{{/if}}
+		{{#if (and (eq database "sqlite") (ne dbSetup "d1"))}},
+		"db:local": {
+			"cache": false,
+			"persistent": true
+		}
+		{{/if}}
+		{{#if (or (eq webDeploy "cloudflare") (eq serverDeploy "cloudflare"))}},
+		"deploy": {
+			"cache": false
+		},
+		"destroy": {
+			"cache": false
 		}
 		{{/if}}
 	}

package/templates/api/orpc/native/utils/orpc.ts.hbs

@@ -3,34 +3,35 @@ import { RPCLink } from "@orpc/client/fetch";
 import { createTanstackQueryUtils } from "@orpc/tanstack-query";
 import { QueryCache, QueryClient } from "@tanstack/react-query";
 import type { AppRouterClient } from "@{{projectName}}/api/routers/index";
+import { env } from "@{{projectName}}/env/native";
 {{#if (eq auth "better-auth")}}
 import { authClient } from "@/lib/auth-client";
 {{/if}}
 
 export const queryClient = new QueryClient({
-  queryCache: new QueryCache({
-    onError: (error) => {
-      console.log(error)
-    },
-  }),
+	queryCache: new QueryCache({
+		onError: (error) => {
+			console.log(error)
+		},
+	}),
 });
 
 export const link = new RPCLink({
-  {{#if (eq backend "self")}}
-  url: `${process.env.EXPO_PUBLIC_SERVER_URL}/api/rpc`,
-  {{else}}
-  url: `${process.env.EXPO_PUBLIC_SERVER_URL}/rpc`,
-  {{/if}}
-  {{#if (eq auth "better-auth")}}
-  headers() {
-    const headers = new Map<string, string>();
-    const cookies = authClient.getCookie();
-    if (cookies) {
-      headers.set("Cookie", cookies);
-    }
-    return Object.fromEntries(headers);
-  },
-  {{/if}}
+{{#if (eq backend "self")}}
+	url: `${env.EXPO_PUBLIC_SERVER_URL}/api/rpc`,
+{{else}}
+	url: `${env.EXPO_PUBLIC_SERVER_URL}/rpc`,
+{{/if}}
+{{#if (eq auth "better-auth")}}
+	headers() {
+		const headers = new Map<string, string>();
+		const cookies = authClient.getCookie();
+		if (cookies) {
+			headers.set("Cookie", cookies);
+		}
+		return Object.fromEntries(headers);
+	},
+{{/if}}
 });
 
 export const client: AppRouterClient = createORPCClient(link);

package/templates/api/orpc/web/nuxt/app/plugins/orpc.ts.hbs

@@ -1,14 +1,12 @@
-import { defineNuxtPlugin, useRuntimeConfig } from '#app'
+import { defineNuxtPlugin } from '#app'
 import type { AppRouterClient } from "@{{projectName}}/api/routers/index";
 import { createORPCClient } from '@orpc/client'
 import { RPCLink } from '@orpc/client/fetch'
 import { createTanstackQueryUtils } from "@orpc/tanstack-query";
 
 export default defineNuxtPlugin(() => {
-  const config = useRuntimeConfig()
-  const serverUrl = config.public.serverURL
-
-  const rpcUrl = `${serverUrl}/rpc`;
+  const config = useRuntimeConfig();
+  const rpcUrl = `${config.public.serverUrl}/rpc`;
 
   const rpcLink = new RPCLink({
     url: rpcUrl,

package/templates/api/orpc/web/react/base/src/utils/orpc.ts.hbs

@@ -9,88 +9,94 @@ import type { RouterClient } from "@orpc/server";
 import { createIsomorphicFn } from "@tanstack/react-start";
 import { appRouter } from "@{{projectName}}/api/routers/index";
 import { createContext } from "@{{projectName}}/api/context";
+{{#unless (eq backend "self")}}
+import { env } from "@{{projectName}}/env/web";
+{{/unless}}
 {{else}}
 import type { AppRouterClient } from "@{{projectName}}/api/routers/index";
+{{#unless (eq backend "self")}}
+import { env } from "@{{projectName}}/env/web";
+{{/unless}}
 {{/if}}
 
 export const queryClient = new QueryClient({
-  queryCache: new QueryCache({
-    onError: (error, query) => {
-      toast.error(`Error: ${error.message}`, {
-        action: {
-          label: "retry",
-          onClick: query.invalidate,
-        },
-      });
-    },
-  }),
+	queryCache: new QueryCache({
+		onError: (error, query) => {
+			toast.error(`Error: ${error.message}`, {
+				action: {
+					label: "retry",
+					onClick: query.invalidate,
+				},
+			});
+		},
+	}),
 });
 
 {{#if (includes frontend "tanstack-start")}}
 const getORPCClient = createIsomorphicFn()
-  .server(() =>
-    createRouterClient(appRouter, {
-      context: async ({ req }) => {
-        {{#if (eq backend "self")}}
-        return createContext({ req });
-        {{else if (eq backend "hono")}}
-        return createContext({ context: req });
-        {{else if (eq backend "elysia")}}
-        return createContext({ context: req });
-        {{else if (eq backend "express")}}
-        return createContext({ req });
-        {{else if (eq backend "fastify")}}
-        return createContext(req.headers);
-        {{else}}
-        return createContext();
-        {{/if}}
-      },
-    }),
-  )
-  .client((): RouterClient<typeof appRouter> => {
-    const link = new RPCLink({
-      url: {{#if (eq backend "self")}}`${window.location.origin}/api/rpc`{{else}}`${import.meta.env.VITE_SERVER_URL}/rpc`{{/if}},
-      {{#if (eq auth "better-auth")}}
-      fetch(url, options) {
-        return fetch(url, {
-          ...options,
-          credentials: "include",
-        });
-      },
-      {{/if}}
-    });
+	.server(() =>
+		createRouterClient(appRouter, {
+			context: async ({ req }) => {
+{{#if (eq backend "self")}}
+				return createContext({ req });
+{{else if (eq backend "hono")}}
+				return createContext({ context: req });
+{{else if (eq backend "elysia")}}
+				return createContext({ context: req });
+{{else if (eq backend "express")}}
+				return createContext({ req });
+{{else if (eq backend "fastify")}}
+				return createContext(req.headers);
+{{else}}
+				return createContext();
+{{/if}}
+			},
+		}),
+	)
+	.client((): RouterClient<typeof appRouter> => {
+			const link = new RPCLink({
+			url: {{#if (eq backend "self")}}`${window.location.origin}/api/rpc`{{else}}`${env.VITE_SERVER_URL}/rpc`{{/if}},
+{{#if (eq auth "better-auth")}}
+			fetch(url, options) {
+				return fetch(url, {
+					...options,
+					credentials: "include",
+				});
+			},
+{{/if}}
+		});
 
-    return createORPCClient(link);
-  });
+		return createORPCClient(link);
+	});
 
 export const client: RouterClient<typeof appRouter> = getORPCClient();
 {{else}}
 export const link = new RPCLink({
-  {{#if (and (eq backend "self") (includes frontend "next"))}}
-  url: `${typeof window !== "undefined" ? window.location.origin : "http://localhost:3001"}/api/rpc`,
-  {{else if (includes frontend "next")}}
-  url: `${process.env.NEXT_PUBLIC_SERVER_URL}/rpc`,
-  {{else}}
-  url: `${import.meta.env.VITE_SERVER_URL}/rpc`,
-  {{/if}}
-  {{#if (eq auth "better-auth")}}
-  fetch(url, options) {
-    return fetch(url, {
-      ...options,
-      credentials: "include",
-    });
-  },
-  {{#if (includes frontend "next")}}
-  headers: async () => {
-    if (typeof window !== "undefined") {
-      return {}
-    }
+{{#if (and (eq backend "self") (includes frontend "next"))}}
+	url: `${typeof window !== "undefined" ? window.location.origin : "http://localhost:3001"}/api/rpc`,
+{{else if (includes frontend "next")}}
+	url: `${env.NEXT_PUBLIC_SERVER_URL}/rpc`,
+{{else}}
+	url: `${env.VITE_SERVER_URL}/rpc`,
+{{/if}}
+{{#if (eq auth "better-auth")}}
+	fetch(url, options) {
+		return fetch(url, {
+			...options,
+			credentials: "include",
+		});
+	},
+{{#if (includes frontend "next")}}
+	headers: async () => {
+		if (typeof window !== "undefined") {
+			return {}
+		}
 
-    const { headers } = await import("next/headers")
-    return Object.fromEntries(await headers())
-  },
-  {{/if}}
-  {{/if}}
+		const { headers } = await import("next/headers")
+		return Object.fromEntries(await headers())
+	},
+{{/if}}
+{{/if}}
 });
 
 export const client: AppRouterClient = createORPCClient(link)

package/templates/api/orpc/web/solid/src/utils/orpc.ts.hbs

@@ -3,25 +3,26 @@ import { RPCLink } from "@orpc/client/fetch";
 import { createTanstackQueryUtils } from "@orpc/tanstack-query";
 import { QueryCache, QueryClient } from "@tanstack/solid-query";
 import type { AppRouterClient } from "@{{projectName}}/api/routers/index";
+import { env } from "@{{projectName}}/env/web";
 
 export const queryClient = new QueryClient({
-  queryCache: new QueryCache({
-    onError: (error) => {
-      console.error(`Error: ${error.message}`);
-    },
-  }),
+	queryCache: new QueryCache({
+		onError: (error) => {
+			console.error(`Error: ${error.message}`);
+		},
+	}),
 });
 
 export const link = new RPCLink({
-  url: `${import.meta.env.VITE_SERVER_URL}/rpc`,
-  {{#if (eq auth "better-auth")}}
-  fetch(url, options) {
-    return fetch(url, {
-      ...options,
-      credentials: "include",
-    });
-  },
-  {{/if}}
+	url: `${env.VITE_SERVER_URL}/rpc`,
+{{#if (eq auth "better-auth")}}
+	fetch(url, options) {
+		return fetch(url, {
+			...options,
+			credentials: "include",
+		});
+	},
+{{/if}}
 });
 
 export const client: AppRouterClient = createORPCClient(link);

package/templates/api/trpc/native/utils/trpc.ts.hbs

@@ -5,18 +5,19 @@ import { QueryClient } from "@tanstack/react-query";
 import { createTRPCClient, httpBatchLink } from "@trpc/client";
 import { createTRPCOptionsProxy } from "@trpc/tanstack-react-query";
 import type { AppRouter } from "@{{projectName}}/api/routers/index";
+import { env } from "@{{projectName}}/env/native";
 
 export const queryClient = new QueryClient();
 
 const trpcClient = createTRPCClient<AppRouter>({
 	links: [
 		httpBatchLink({
-			 {{#if  (eq backend "self")}}
-			url: `${process.env.EXPO_PUBLIC_SERVER_URL}/api/trpc`,
-			{{else}}
-			url: `${process.env.EXPO_PUBLIC_SERVER_URL}/trpc`,
-			{{/if}}
-			{{#if (eq auth "better-auth")}}
+{{#if (eq backend "self")}}
+			url: `${env.EXPO_PUBLIC_SERVER_URL}/api/trpc`,
+{{else}}
+			url: `${env.EXPO_PUBLIC_SERVER_URL}/trpc`,
+{{/if}}
+{{#if (eq auth "better-auth")}}
 			headers() {
 				const headers = new Map<string, string>();
 				const cookies = authClient.getCookie();
@@ -25,7 +26,7 @@ const trpcClient = createTRPCClient<AppRouter>({
 				}
 				return Object.fromEntries(headers);
 			},
-			{{/if}}
+{{/if}}
 		}),
 	],
 });

package/templates/api/trpc/web/react/base/src/utils/trpc.ts.hbs

@@ -4,45 +4,46 @@ import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import { createTRPCOptionsProxy } from '@trpc/tanstack-react-query';
 import type { AppRouter } from "@{{projectName}}/api/routers/index";
 import { toast } from 'sonner';
+{{#unless (eq backend "self")}}
+import { env } from "@{{projectName}}/env/web";
+{{/unless}}
 
 export const queryClient = new QueryClient({
-  queryCache: new QueryCache({
-    onError: (error, query) => {
-      toast.error(error.message, {
-        action: {
-          label: "retry",
-          onClick: query.invalidate,
-        },
-      });
-    },
-  }),
+	queryCache: new QueryCache({
+		onError: (error, query) => {
+			toast.error(error.message, {
+				action: {
+					label: "retry",
+					onClick: query.invalidate,
+				},
+			});
+		},
+	}),
 });
 
 const trpcClient = createTRPCClient<AppRouter>({
-  links: [
-    httpBatchLink({
-      {{#if (and (eq backend "self") (includes frontend 'next'))}}
-      url: "/api/trpc",
-      {{else if (includes frontend 'next')}}
-      url: `${process.env.NEXT_PUBLIC_SERVER_URL}/trpc`,
-      {{else}}
-      url: `${import.meta.env.VITE_SERVER_URL}/trpc`,
-      {{/if}}
-      {{#if (eq auth "better-auth")}}
-      fetch(url, options) {
-        return fetch(url, {
-          ...options,
-          credentials: "include",
-        });
-      },
-      {{/if}}
-    }),
-  ],
+	links: [
+		httpBatchLink({
+{{#if (eq backend "self")}}
+			url: "/api/trpc",
+{{else}}
+			url: `${env.NEXT_PUBLIC_SERVER_URL}/trpc`,
+{{/if}}
+{{#if (eq auth "better-auth")}}
+			fetch(url, options) {
+				return fetch(url, {
+					...options,
+					credentials: "include",
+				});
+			},
+{{/if}}
+		}),
+	],
 })
 
 export const trpc = createTRPCOptionsProxy<AppRouter>({
-  client: trpcClient,
-  queryClient,
+	client: trpcClient,
+	queryClient,
 });
 
 {{else if (includes frontend 'tanstack-start')}}
@@ -50,7 +51,7 @@ import { createTRPCContext } from "@trpc/tanstack-react-query";
 import type { AppRouter } from "@{{projectName}}/api/routers/index";
 
 export const { TRPCProvider, useTRPC, useTRPCClient } =
-  createTRPCContext<AppRouter>();
+	createTRPCContext<AppRouter>();
 
 {{else}}
 import type { AppRouter } from "@{{projectName}}/api/routers/index";
@@ -58,38 +59,39 @@ import { QueryCache, QueryClient } from "@tanstack/react-query";
 import { createTRPCClient, httpBatchLink } from "@trpc/client";
 import { createTRPCOptionsProxy } from "@trpc/tanstack-react-query";
 import { toast } from "sonner";
+import { env } from "@{{projectName}}/env/web";
 
 export const queryClient = new QueryClient({
-  queryCache: new QueryCache({
-    onError: (error, query) => {
-      toast.error(error.message, {
-        action: {
-          label: "retry",
-          onClick: query.invalidate,
-        },
-      });
-    },
-  }),
+	queryCache: new QueryCache({
+		onError: (error, query) => {
+			toast.error(error.message, {
+				action: {
+					label: "retry",
+					onClick: query.invalidate,
+				},
+			});
+		},
+	}),
 });
 
 export const trpcClient = createTRPCClient<AppRouter>({
-  links: [
-    httpBatchLink({
-      url: `${import.meta.env.VITE_SERVER_URL}/trpc`,
-      {{#if (eq auth "better-auth")}}
-      fetch(url, options) {
-        return fetch(url, {
-          ...options,
-          credentials: "include",
-        });
-      },
-      {{/if}}
-    }),
-  ],
+	links: [
+		httpBatchLink({
+			url: `${env.VITE_SERVER_URL}/trpc`,
+{{#if (eq auth "better-auth")}}
+			fetch(url, options) {
+				return fetch(url, {
+					...options,
+					credentials: "include",
+				});
+			},
+{{/if}}
+		}),
+	],
 });
 
 export const trpc = createTRPCOptionsProxy<AppRouter>({
-  client: trpcClient,
-  queryClient,
+	client: trpcClient,
+	queryClient,
 });
 {{/if}}

package/templates/auth/better-auth/convex/backend/convex/auth.ts.hbs

@@ -8,10 +8,9 @@ import { convex, crossDomain } from "@convex-dev/better-auth/plugins";
 import { convex } from "@convex-dev/better-auth/plugins";
 {{/if}}
 import { components } from "./_generated/api";
-import { DataModel } from "./_generated/dataModel";
+import type { DataModel } from "./_generated/dataModel";
 import { query } from "./_generated/server";
 import { betterAuth } from "better-auth";
-import { v } from "convex/values";
 import authConfig from "./auth.config";
 
 {{#if (or (includes frontend "tanstack-start") (includes frontend "next"))}}
@@ -63,8 +62,7 @@ export { createAuth };
 
 export const getCurrentUser = query({
   args: {},
-  returns: v.any(),
-  handler: async function (ctx) {
-    return authComponent.getAuthUser(ctx);
+  handler: async (ctx) => {
+    return await authComponent.safeGetAuthUser(ctx);
   },
 });

package/templates/auth/better-auth/convex/backend/convex/privateData.ts.hbs

@@ -1,16 +1,17 @@
 import { query } from "./_generated/server";
+import { authComponent } from "./auth";
 
 export const get = query({
-    args: {},
-    handler: async (ctx) => {
-        const identity = await ctx.auth.getUserIdentity();
-        if (identity === null) {
-            return {
-                message: "Not authenticated",
-            };
-        }
-        return {
-            message: "This is private",
-        };
-    },
+  args: {},
+  handler: async (ctx) => {
+    const authUser = await authComponent.safeGetAuthUser(ctx);
+    if (!authUser) {
+      return {
+        message: "Not authenticated",
+      };
+    }
+    return {
+      message: "This is private",
+    };
+  },
 });

package/templates/auth/better-auth/convex/native/base/lib/auth-client.ts.hbs

@@ -3,15 +3,16 @@ import { convexClient } from "@convex-dev/better-auth/client/plugins";
 import { expoClient } from "@better-auth/expo/client";
 import Constants from "expo-constants";
 import * as SecureStore from "expo-secure-store";
+import { env } from "@{{projectName}}/env/native";
 
 export const authClient = createAuthClient({
-  baseURL: process.env.EXPO_PUBLIC_CONVEX_SITE_URL,
-  plugins: [
-    expoClient({
-      scheme: Constants.expoConfig?.scheme as string,
-      storagePrefix: Constants.expoConfig?.scheme as string,
-      storage: SecureStore,
-    }),
-    convexClient(),
-  ],
+	baseURL: env.EXPO_PUBLIC_CONVEX_SITE_URL,
+	plugins: [
+		expoClient({
+			scheme: Constants.expoConfig?.scheme as string,
+			storagePrefix: Constants.expoConfig?.scheme as string,
+			storage: SecureStore,
+		}),
+		convexClient(),
+	],
 });

package/templates/auth/better-auth/convex/web/react/next/src/lib/auth-client.ts.hbs

@@ -2,5 +2,5 @@ import { createAuthClient } from "better-auth/react";
 import { convexClient } from "@convex-dev/better-auth/client/plugins";
 
 export const authClient = createAuthClient({
-    plugins: [convexClient()],
-});
+  plugins: [convexClient()],
+});

package/templates/auth/better-auth/convex/web/react/next/src/lib/auth-server.ts.hbs

@@ -1,14 +1,16 @@
 import { convexBetterAuthNextJs } from "@convex-dev/better-auth/nextjs";
+import { isAuthError } from "@/lib/utils";
+import { env } from "@{{projectName}}/env/web";
 
 export const {
-  handler,
-  preloadAuthQuery,
-  isAuthenticated,
-  getToken,
-  fetchAuthQuery,
-  fetchAuthMutation,
-  fetchAuthAction,
+	handler,
+	preloadAuthQuery,
+	isAuthenticated,
+	getToken,
+	fetchAuthQuery,
+	fetchAuthMutation,
+	fetchAuthAction,
 } = convexBetterAuthNextJs({
-  convexUrl: process.env.NEXT_PUBLIC_CONVEX_URL!,
-  convexSiteUrl: process.env.NEXT_PUBLIC_CONVEX_SITE_URL!,
+	convexUrl: env.NEXT_PUBLIC_CONVEX_URL,
+	convexSiteUrl: env.NEXT_PUBLIC_CONVEX_SITE_URL,
 });

package/templates/auth/better-auth/convex/web/react/tanstack-router/src/lib/auth-client.ts.hbs

@@ -1,10 +1,11 @@
 import { createAuthClient } from "better-auth/react";
 import {
-    convexClient,
-    crossDomainClient,
+	convexClient,
+	crossDomainClient,
 } from "@convex-dev/better-auth/client/plugins";
+import { env } from "@{{projectName}}/env/web";
 
 export const authClient = createAuthClient({
-    baseURL: import.meta.env.VITE_CONVEX_SITE_URL,
-    plugins: [convexClient(), crossDomainClient()],
+	baseURL: env.VITE_CONVEX_SITE_URL,
+	plugins: [convexClient(), crossDomainClient()],
 });

package/templates/auth/better-auth/convex/web/react/tanstack-start/src/lib/auth-server.ts.hbs

@@ -1,12 +1,13 @@
 import { convexBetterAuthReactStart } from "@convex-dev/better-auth/react-start";
+import { env } from "@{{projectName}}/env/web";
 
 export const {
-  handler,
-  getToken,
-  fetchAuthQuery,
-  fetchAuthMutation,
-  fetchAuthAction,
+	handler,
+	getToken,
+	fetchAuthQuery,
+	fetchAuthMutation,
+	fetchAuthAction,
 } = convexBetterAuthReactStart({
-  convexUrl: process.env.VITE_CONVEX_URL!,
-  convexSiteUrl: process.env.VITE_CONVEX_SITE_URL!,
+	convexUrl: env.VITE_CONVEX_URL,
+	convexSiteUrl: env.VITE_CONVEX_SITE_URL,
 });