create-pilotprojects-app 0.1.0

package/templates/base/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "private": true,
+  "scripts": {
+    "build": "turbo build",
+    "dev": "turbo dev",
+    "lint": "turbo lint",
+    "type-check": "turbo type-check",
+    "test": "turbo test",
+    "format": "prettier --write \"**/*.{ts,tsx,md}\""
+  },
+  "devDependencies": {
+    "prettier": "^3.3.0",
+    "turbo": "^2.0.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "pnpm": ">=9.0.0"
+  },
+  "packageManager": "pnpm@9.0.0",
+  "pnpm": {
+    "overrides": {
+      "nativewind": "~4.1.0",
+      "react-native-css-interop": "~0.1.0",
+      "react-native-screens": "~4.4.0",
+      "react-native-reanimated": "~3.16.0"
+    }
+  }
+}

package/templates/base/turbo.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "globalEnv": [
+    "NODE_ENV",
+    "SUPABASE_URL",
+    "SUPABASE_ANON_KEY",
+    "NEXT_PUBLIC_SUPABASE_URL",
+    "NEXT_PUBLIC_SUPABASE_ANON_KEY"
+  ],
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": [".next/**", "dist/**", "!.next/cache/**"]
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "lint": {
+      "dependsOn": ["^build"]
+    },
+    "type-check": {
+      "dependsOn": ["^build"]
+    },
+    "test": {
+      "dependsOn": ["^build"],
+      "outputs": ["coverage/**"]
+    },
+    "db:generate": { "cache": false },
+    "db:migrate": { "cache": false },
+    "db:studio": { "cache": false, "persistent": true }
+  }
+}

package/templates/packages/api/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "{{PACKAGE_SCOPE}}/api",
+  "version": "0.1.0",
+  "private": true,
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src"
+  },
+  "dependencies": {
+    "{{PACKAGE_SCOPE}}/db": "workspace:*",
+    "{{PACKAGE_SCOPE}}/validators": "workspace:*",
+    "@trpc/server": "^11.0.0",
+    "superjson": "^2.2.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/templates/packages/api/src/features/auth/auth.router.ts

@@ -0,0 +1,8 @@
+import { createTRPCRouter, protectedProcedure } from "../../trpc";
+import { syncUserOnSignIn } from "./auth.service";
+
+export const authRouter = createTRPCRouter({
+  syncUser: protectedProcedure.mutation(({ ctx }) =>
+    syncUserOnSignIn(ctx.db, ctx.user),
+  ),
+});

package/templates/packages/api/src/features/auth/auth.schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const signUpSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  displayName: z.string().min(1).max(50),
+});
+
+export type SignUpInput = z.infer<typeof signUpSchema>;

package/templates/packages/api/src/features/auth/auth.service.ts

@@ -0,0 +1,24 @@
+import { TRPCError } from "@trpc/server";
+
+import type { Db } from "{{PACKAGE_SCOPE}}/db";
+
+import { upsertUser } from "../user/user.service";
+
+export async function syncUserOnSignIn(
+  db: Db,
+  user: { id: string; email?: string; user_metadata?: Record<string, unknown> },
+) {
+  if (!user.email) throw new TRPCError({ code: "BAD_REQUEST", message: "User has no email" });
+
+  const displayName =
+    typeof user.user_metadata?.["full_name"] === "string"
+      ? user.user_metadata["full_name"]
+      : user.email.split("@")[0];
+
+  return upsertUser(db, { id: user.id, email: user.email, displayName });
+}
+
+export async function requireAuth(userId: string | undefined): Promise<string> {
+  if (!userId) throw new TRPCError({ code: "UNAUTHORIZED" });
+  return userId;
+}

package/templates/packages/api/src/features/user/user.router.ts

@@ -0,0 +1,21 @@
+import { createTRPCRouter, protectedProcedure } from "../../trpc";
+import { getUserSchema, updateUserSchema } from "./user.schema";
+import { deleteUser, getUserById, updateUser } from "./user.service";
+
+export const userRouter = createTRPCRouter({
+  me: protectedProcedure.query(({ ctx }) =>
+    getUserById(ctx.db, ctx.user.id),
+  ),
+
+  byId: protectedProcedure
+    .input(getUserSchema)
+    .query(({ ctx, input }) => getUserById(ctx.db, input.userId)),
+
+  update: protectedProcedure
+    .input(updateUserSchema)
+    .mutation(({ ctx, input }) => updateUser(ctx.db, ctx.user.id, input)),
+
+  delete: protectedProcedure.mutation(({ ctx }) =>
+    deleteUser(ctx.db, ctx.user.id),
+  ),
+});

package/templates/packages/api/src/features/user/user.schema.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const updateUserSchema = z.object({
+  displayName: z.string().min(1).max(50),
+  avatarUrl: z.string().url().optional(),
+});
+
+export const getUserSchema = z.object({
+  userId: z.string().uuid(),
+});
+
+export type UpdateUserInput = z.infer<typeof updateUserSchema>;
+export type GetUserInput    = z.infer<typeof getUserSchema>;

package/templates/packages/api/src/features/user/user.service.ts

@@ -0,0 +1,41 @@
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+import { users, type Db } from "{{PACKAGE_SCOPE}}/db";
+
+import type { UpdateUserInput } from "./user.schema";
+
+export async function getUserById(db: Db, userId: string) {
+  const [user] = await db.select().from(users).where(eq(users.id, userId));
+  if (!user) throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
+  return user;
+}
+
+export async function updateUser(db: Db, userId: string, input: UpdateUserInput) {
+  const [updated] = await db
+    .update(users)
+    .set({ ...input, updatedAt: new Date() })
+    .where(eq(users.id, userId))
+    .returning();
+  if (!updated) throw new TRPCError({ code: "NOT_FOUND" });
+  return updated;
+}
+
+export async function deleteUser(db: Db, userId: string) {
+  await db.delete(users).where(eq(users.id, userId));
+}
+
+export async function upsertUser(
+  db: Db,
+  data: { id: string; email: string; displayName?: string },
+) {
+  const [user] = await db
+    .insert(users)
+    .values({ id: data.id, email: data.email, displayName: data.displayName })
+    .onConflictDoUpdate({
+      target: users.id,
+      set: { email: data.email, updatedAt: new Date() },
+    })
+    .returning();
+  return user!;
+}

package/templates/packages/api/src/index.ts

@@ -0,0 +1,9 @@
+export { appRouter } from "./root";
+export type { AppRouter } from "./root";
+export type { TRPCContext, AuthedContext } from "./trpc";
+
+import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
+import type { AppRouter } from "./root";
+
+export type RouterInputs  = inferRouterInputs<AppRouter>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;

package/templates/packages/api/src/root.ts

@@ -0,0 +1,10 @@
+import { createTRPCRouter } from "./trpc";
+import { authRouter } from "./features/auth/auth.router";
+import { userRouter } from "./features/user/user.router";
+
+export const appRouter = createTRPCRouter({
+  auth: authRouter,
+  user: userRouter,
+});
+
+export type AppRouter = typeof appRouter;

package/templates/packages/api/src/trpc.ts

@@ -0,0 +1,42 @@
+import { initTRPC, TRPCError } from "@trpc/server";
+import superjson from "superjson";
+import { ZodError } from "zod";
+
+import type { db } from "{{PACKAGE_SCOPE}}/db";
+import type { Session, User } from "@supabase/supabase-js";
+
+export type TRPCContext = {
+  db: typeof db;
+  session: Session | null;
+  user: User | null;
+};
+
+export type AuthedContext = TRPCContext & {
+  session: Session;
+  user: User;
+};
+
+const t = initTRPC.context<TRPCContext>().create({
+  transformer: superjson,
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError: error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+export const createTRPCRouter  = t.router;
+export const publicProcedure   = t.procedure;
+
+const enforceAuth = t.middleware(({ ctx, next }) => {
+  if (!ctx.session || !ctx.user) {
+    throw new TRPCError({ code: "UNAUTHORIZED" });
+  }
+  return next({ ctx: { ...ctx, session: ctx.session, user: ctx.user } });
+});
+
+export const protectedProcedure = t.procedure.use(enforceAuth);

package/templates/packages/api/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "{{PACKAGE_SCOPE}}/config/typescript/base",
+  "include": ["src"]
+}

package/templates/packages/auth/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "{{PACKAGE_SCOPE}}/auth",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".":            "./src/index.ts",
+    "./server":     "./src/server.ts",
+    "./client":     "./src/client.ts",
+    "./middleware":  "./src/middleware.ts"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.45.0",
+    "@supabase/ssr": "^0.5.0"
+  },
+  "devDependencies": {
+    "{{PACKAGE_SCOPE}}/config": "workspace:*",
+    "@types/node": "^20.0.0",
+    "next": "15.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/templates/packages/auth/src/client.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient as _create } from "@supabase/ssr";
+
+export function createBrowserClient() {
+  return _create(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+  );
+}

package/templates/packages/auth/src/index.ts

@@ -0,0 +1,3 @@
+export { createServerClient } from "./server";
+export { createBrowserClient } from "./client";
+export { updateSession } from "./middleware";

package/templates/packages/auth/src/middleware.ts

@@ -0,0 +1,25 @@
+import { createServerClient, type CookieOptions } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function updateSession(request: NextRequest) {
+  let response = NextResponse.next({ request });
+
+  const supabase = createServerClient(
+    process.env.SUPABASE_URL!,
+    process.env.SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        getAll: () => request.cookies.getAll(),
+        setAll: (cookiesToSet: { name: string; value: string; options: CookieOptions }[]) => {
+          cookiesToSet.forEach(({ name, value, options }) => {
+            request.cookies.set(name, value);
+            response.cookies.set(name, value, options);
+          });
+        },
+      },
+    },
+  );
+
+  await supabase.auth.getUser();
+  return response;
+}

package/templates/packages/auth/src/server.ts

@@ -0,0 +1,15 @@
+import { createServerClient as _create, type CookieOptions } from "@supabase/ssr";
+import type { ReadonlyRequestCookies } from "next/dist/server/web/spec-extension/adapters/request-cookies";
+
+export function createServerClient(cookieStore: ReadonlyRequestCookies) {
+  return _create(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!, {
+    cookies: {
+      getAll: () => cookieStore.getAll(),
+      setAll: (cookiesToSet: { name: string; value: string; options: CookieOptions }[]) => {
+        cookiesToSet.forEach(({ name, value, options }) =>
+          cookieStore.set(name, value, options),
+        );
+      },
+    },
+  });
+}

package/templates/packages/auth/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "{{PACKAGE_SCOPE}}/config/typescript/base",
+  "include": ["src"]
+}

package/templates/packages/config/eslint/base.js

@@ -0,0 +1,28 @@
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:import/recommended",
+    "plugin:import/typescript",
+    "prettier",
+  ],
+  plugins: ["@typescript-eslint", "import"],
+  parser: "@typescript-eslint/parser",
+  rules: {
+    "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
+    "@typescript-eslint/consistent-type-imports": [
+      "error",
+      { prefer: "type-imports", fixStyle: "inline-type-imports" },
+    ],
+    "import/order": [
+      "error",
+      {
+        groups: ["builtin", "external", "internal", "parent", "sibling", "index"],
+        "newlines-between": "always",
+        alphabetize: { order: "asc" },
+      },
+    ],
+    "no-console": ["warn", { allow: ["warn", "error"] }],
+  },
+};

package/templates/packages/config/eslint/nextjs.js

@@ -0,0 +1,10 @@
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: [
+    "./base.js",
+    "next/core-web-vitals",
+  ],
+  rules: {
+    "@next/next/no-html-link-for-pages": "off",
+  },
+};

package/templates/packages/config/eslint/react-native.js

@@ -0,0 +1,18 @@
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: [
+    "./base.js",
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended",
+    "plugin:react-native/all",
+  ],
+  plugins: ["react", "react-hooks", "react-native"],
+  settings: {
+    react: { version: "detect" },
+  },
+  rules: {
+    "react/react-in-jsx-scope": "off",
+    "react-native/no-raw-text": "off",
+    "react-native/no-color-literals": "warn",
+  },
+};

package/templates/packages/config/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "{{PACKAGE_SCOPE}}/config",
+  "version": "0.1.0",
+  "private": true,
+  "exports": {
+    "./eslint/base":             "./eslint/base.js",
+    "./eslint/nextjs":           "./eslint/nextjs.js",
+    "./eslint/react-native":     "./eslint/react-native.js",
+    "./typescript/base":         "./typescript/base.json",
+    "./typescript/nextjs":       "./typescript/nextjs.json",
+    "./typescript/react-native": "./typescript/react-native.json"
+  }
+}

package/templates/packages/config/typescript/base.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/templates/packages/config/typescript/nextjs.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "allowJs": true,
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "exclude": ["node_modules", ".next", "dist"]
+}

package/templates/packages/config/typescript/react-native.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "jsx": "react-native",
+    "allowSyntheticDefaultImports": true
+  },
+  "exclude": ["node_modules", "dist", ".expo"]
+}

package/templates/packages/db/.env.example

@@ -0,0 +1 @@
+DATABASE_URL=postgresql://postgres:postgres@localhost:54322/postgres

package/templates/packages/db/drizzle.config.ts

@@ -0,0 +1,13 @@
+import "dotenv/config";
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/schema/index.ts",
+  out: "./src/migrations",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+  verbose: true,
+  strict: true,
+});

package/templates/packages/db/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "{{PACKAGE_SCOPE}}/db",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".":        "./src/index.ts",
+    "./schema": "./src/schema/index.ts"
+  },
+  "scripts": {
+    "db:generate": "drizzle-kit generate",
+    "db:migrate":  "drizzle-kit migrate",
+    "db:studio":   "drizzle-kit studio",
+    "db:push":     "drizzle-kit push",
+    "type-check":  "tsc --noEmit"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "drizzle-orm": "^0.33.0",
+    "postgres": "^3.4.0"
+  },
+  "devDependencies": {
+    "{{PACKAGE_SCOPE}}/config": "workspace:*",
+    "@types/node": "^20.0.0",
+    "drizzle-kit": "^0.24.0",
+    "typescript": "^5.5.0"
+  }
+}

package/templates/packages/db/src/index.ts

@@ -0,0 +1,14 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+import * as schema from "./schema";
+
+const client = postgres(process.env.DATABASE_URL!, {
+  max: 1,
+  ssl: process.env.NODE_ENV === "production" ? "require" : false,
+});
+
+export const db = drizzle(client, { schema });
+
+export type Db = typeof db;
+export * from "./schema";

package/templates/packages/db/src/schema/index.ts

@@ -0,0 +1 @@
+export * from "./users";

package/templates/packages/db/src/schema/users.ts

@@ -0,0 +1,13 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: uuid("id").primaryKey(),
+  email: text("email").notNull().unique(),
+  displayName: text("display_name"),
+  avatarUrl: text("avatar_url"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+});
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;

package/templates/packages/db/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "{{PACKAGE_SCOPE}}/config/typescript/base",
+  "include": ["src"]
+}

package/templates/packages/email/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "{{PACKAGE_SCOPE}}/email",
+  "version": "0.1.0",
+  "private": true,
+  "exports": {
+    ".": "./src/index.ts",
+    "./templates/*": "./src/templates/*.tsx"
+  },
+  "scripts": {
+    "email:dev": "react-email dev --dir src/templates --port 3100",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@react-email/components": "latest",
+    "react": "^18.3.0",
+    "react-email": "latest",
+    "resend": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "typescript": "^5.5.0"
+  }
+}

package/templates/packages/email/src/index.ts

@@ -0,0 +1,2 @@
+export { resend, FROM } from "./resend";
+export { WelcomeEmail } from "./templates/welcome";

package/templates/packages/email/src/resend.ts

@@ -0,0 +1,8 @@
+import { Resend } from "resend";
+
+export const resend = new Resend(process.env.RESEND_API_KEY);
+
+export const FROM = {
+  noreply: "{{PROJECT_NAME}} <noreply@yourapp.com>",
+  support:  "{{PROJECT_NAME}} Support <support@yourapp.com>",
+} as const;