create-kuckit-app 0.3.5 → 0.4.1

package/templates/base/apps/server/src/rpc-router-registry.ts

@@ -1,26 +0,0 @@
-import type { ApiRegistration } from '@kuckit/sdk'
-
-/**
- * Central mutable RPC router object used by RPCHandler.
- *
- * Module routers are wired into this object during the SDK loader's
- * "wire" phase, before RPCHandler is instantiated.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const rootRpcRouter: Record<string, any> = {}
-
-/**
- * Wire module RPC routers into the central router object.
- * Called from the SDK loader's onApiRegistrations callback.
- */
-export const wireModuleRpcRouters = (registrations: ApiRegistration[]): void => {
-	for (const reg of registrations) {
-		if (reg.type !== 'rpc-router') continue
-
-		if (rootRpcRouter[reg.name]) {
-			throw new Error(`Duplicate RPC router name: "${reg.name}"`)
-		}
-
-		rootRpcRouter[reg.name] = reg.router
-	}
-}

package/templates/base/apps/server/src/rpc.ts

@@ -1,31 +0,0 @@
-import { RPCHandler } from '@orpc/server/node'
-import { onError } from '@orpc/server'
-import { createContext } from '@__APP_NAME_KEBAB__/api'
-import type { Express } from 'express'
-import { rootRpcRouter } from './rpc-router-registry'
-
-/**
- * Setup oRPC handler
- *
- * IMPORTANT: This must be called AFTER setupContainerMiddleware() has completed,
- * which ensures all module routers have been wired into rootRpcRouter.
- */
-export const setupRPC = (app: Express) => {
-	const rpcHandler = new RPCHandler(rootRpcRouter, {
-		interceptors: [
-			onError((error) => {
-				console.error('[RPC Error]', error)
-			}),
-		],
-	})
-
-	app.use(async (req, res, next) => {
-		const result = await rpcHandler.handle(req, res, {
-			prefix: '/rpc',
-			context: await createContext({ req }),
-		})
-
-		if (result.matched) return
-		next()
-	})
-}

package/templates/base/apps/web/src/providers/KuckitProvider.tsx

@@ -1,123 +0,0 @@
-import { createContext, useContext, useEffect, useState, useMemo, type ReactNode } from 'react'
-import { RouterProvider, createRouter } from '@tanstack/react-router'
-import {
-	loadKuckitClientModules,
-	KuckitNavProvider,
-	KuckitSlotProvider,
-	KuckitRpcProvider,
-	type LoadClientModulesResult,
-	type RouteRegistry,
-	type NavRegistry,
-	type SlotRegistry,
-} from '@kuckit/sdk-react'
-import { routeTree } from '../routeTree.gen'
-import { useServices } from './ServicesProvider'
-import { getClientModuleSpecs } from '../modules.client'
-
-interface KuckitContextValue {
-	routeRegistry: RouteRegistry
-	navRegistry: NavRegistry
-	slotRegistry: SlotRegistry
-	isLoaded: boolean
-}
-
-const KuckitContext = createContext<KuckitContextValue | null>(null)
-
-/**
- * Hook to access Kuckit registries
- */
-export function useKuckit(): KuckitContextValue {
-	const ctx = useContext(KuckitContext)
-	if (!ctx) {
-		throw new Error('useKuckit must be used within a KuckitProvider')
-	}
-	return ctx
-}
-
-interface KuckitProviderProps {
-	children?: ReactNode
-}
-
-/**
- * KuckitProvider handles module loading and router creation
- */
-export function KuckitProvider({ children }: KuckitProviderProps) {
-	const { orpc, queryClient, rpcClient } = useServices()
-	const [loadResult, setLoadResult] = useState<LoadClientModulesResult | null>(null)
-	const [error, setError] = useState<Error | null>(null)
-
-	useEffect(() => {
-		let cancelled = false
-
-		const loadModules = async () => {
-			try {
-				const result = await loadKuckitClientModules({
-					orpc,
-					queryClient,
-					env: import.meta.env.MODE,
-					modules: getClientModuleSpecs(),
-				})
-
-				if (!cancelled) {
-					setLoadResult(result)
-				}
-			} catch (err) {
-				if (!cancelled) {
-					setError(err instanceof Error ? err : new Error(String(err)))
-				}
-			}
-		}
-
-		loadModules()
-
-		return () => {
-			cancelled = true
-		}
-	}, [orpc, queryClient])
-
-	const router = useMemo(() => {
-		if (!loadResult) return null
-		return createRouter({
-			routeTree,
-			defaultPreload: 'intent',
-			context: { orpc, queryClient },
-		})
-	}, [loadResult, orpc, queryClient])
-
-	if (error) {
-		return (
-			<div style={{ padding: '2rem', color: 'red' }}>
-				<h2>Failed to load modules</h2>
-				<p>{error.message}</p>
-			</div>
-		)
-	}
-
-	if (!loadResult || !router) {
-		return (
-			<div style={{ padding: '2rem' }}>
-				<p>Loading...</p>
-			</div>
-		)
-	}
-
-	const contextValue: KuckitContextValue = {
-		routeRegistry: loadResult.routeRegistry,
-		navRegistry: loadResult.navRegistry,
-		slotRegistry: loadResult.slotRegistry,
-		isLoaded: true,
-	}
-
-	return (
-		<KuckitContext.Provider value={contextValue}>
-			<KuckitRpcProvider client={rpcClient}>
-				<KuckitNavProvider registry={loadResult.navRegistry}>
-					<KuckitSlotProvider registry={loadResult.slotRegistry}>
-						<RouterProvider router={router} />
-						{children}
-					</KuckitSlotProvider>
-				</KuckitNavProvider>
-			</KuckitRpcProvider>
-		</KuckitContext.Provider>
-	)
-}

package/templates/base/apps/web/src/providers/ServicesProvider.tsx

@@ -1,47 +0,0 @@
-import { createContext, useContext, useMemo, type ReactNode } from 'react'
-import { QueryClientProvider } from '@tanstack/react-query'
-import {
-	createQueryClient,
-	createRPCLink,
-	createRPCClient,
-	createORPCUtils,
-	createAuthClientService,
-	type Services,
-} from '../services'
-
-const ServicesContext = createContext<Services | null>(null)
-
-interface ServicesProviderProps {
-	children: ReactNode
-}
-
-export function ServicesProvider({ children }: ServicesProviderProps) {
-	const services = useMemo<Services>(() => {
-		const queryClient = createQueryClient()
-		const link = createRPCLink()
-		const rpcClient = createRPCClient(link)
-		const orpc = createORPCUtils(rpcClient)
-		const authClient = createAuthClientService()
-
-		return {
-			queryClient,
-			rpcClient,
-			orpc,
-			authClient,
-		}
-	}, [])
-
-	return (
-		<ServicesContext.Provider value={services}>
-			<QueryClientProvider client={services.queryClient}>{children}</QueryClientProvider>
-		</ServicesContext.Provider>
-	)
-}
-
-export function useServices(): Services {
-	const context = useContext(ServicesContext)
-	if (!context) {
-		throw new Error('useServices must be used within a ServicesProvider')
-	}
-	return context
-}

package/templates/base/apps/web/src/services/auth-client.ts

@@ -1,12 +0,0 @@
-import type { auth } from '@__APP_NAME_KEBAB__/auth'
-import { createAuthClient } from 'better-auth/react'
-import { inferAdditionalFields } from 'better-auth/client/plugins'
-
-export function createAuthClientService() {
-	return createAuthClient({
-		baseURL: import.meta.env.VITE_API_URL || 'http://localhost:3000',
-		plugins: [inferAdditionalFields<typeof auth>()],
-	})
-}
-
-export type AuthClient = ReturnType<typeof createAuthClientService>

package/templates/base/apps/web/src/services/index.ts

@@ -1,3 +0,0 @@
-export * from './types'
-export * from './rpc'
-export * from './auth-client'

package/templates/base/apps/web/src/services/rpc.ts

@@ -1,29 +0,0 @@
-import { createORPCClient } from '@orpc/client'
-import { RPCLink } from '@orpc/client/fetch'
-import { createTanstackQueryUtils } from '@orpc/tanstack-query'
-import { QueryClient } from '@tanstack/react-query'
-import type { RPCClient, ORPCUtils } from './types'
-
-export function createQueryClient(): QueryClient {
-	return new QueryClient()
-}
-
-export function createRPCLink() {
-	return new RPCLink({
-		url: `${import.meta.env.VITE_API_URL || 'http://localhost:3000'}/rpc`,
-		fetch(url, options) {
-			return fetch(url, {
-				...options,
-				credentials: 'include',
-			})
-		},
-	})
-}
-
-export function createRPCClient(link: ReturnType<typeof createRPCLink>): RPCClient {
-	return createORPCClient(link)
-}
-
-export function createORPCUtils(client: RPCClient): ORPCUtils {
-	return createTanstackQueryUtils(client)
-}

package/templates/base/apps/web/src/services/types.ts

@@ -1,14 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query'
-import type { createTanstackQueryUtils } from '@orpc/tanstack-query'
-import type { AuthClient } from './auth-client'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type RPCClient = Record<string, any>
-export type ORPCUtils = ReturnType<typeof createTanstackQueryUtils<RPCClient>>
-
-export interface Services {
-	queryClient: QueryClient
-	rpcClient: RPCClient
-	orpc: ORPCUtils
-	authClient: AuthClient
-}

package/templates/base/packages/api/AGENTS.md

@@ -1,66 +0,0 @@
-# AGENTS.md - API Package
-
-> See root [AGENTS.md](../../AGENTS.md) for SDK Module System patterns
-
-## Purpose
-
-Shared API context, types, and procedure definitions for oRPC.
-
-## Key Files
-
-| File         | Purpose                          |
-| ------------ | -------------------------------- |
-| `context.ts` | Request context type definitions |
-| `index.ts`   | Public exports                   |
-
-## Procedure Types
-
-```typescript
-import { publicProcedure, protectedProcedure } from '@__APP_NAME_KEBAB__/api'
-
-// Public - no authentication required
-export const healthRouter = {
-	ping: publicProcedure.handler(() => 'pong'),
-}
-
-// Protected - requires authenticated user
-export const itemsRouter = {
-	list: protectedProcedure.handler(async ({ context }) => {
-		const userId = context.session?.user?.id
-		// ...
-	}),
-}
-```
-
-## Context Structure
-
-The API context provides:
-
-- `di` - Scoped DI container for the request
-- `session` - Current user session (when using `protectedProcedure`)
-
-## Typing DI Access in Routers
-
-Use a module-local interface to type `context.di.cradle`:
-
-```typescript
-// In your module's router file
-interface ItemsCradle {
-	itemRepository: ItemRepository
-	createItem: (input: CreateItemInput) => Promise<Item>
-}
-
-export const itemsRouter = {
-	create: protectedProcedure.input(createItemSchema).handler(async ({ input, context }) => {
-		const { createItem } = context.di.cradle as ItemsCradle
-		return createItem(input)
-	}),
-}
-```
-
-**Why module-local interfaces:**
-
-- Type assertion stays within the module
-- Module remains self-contained
-- Server app doesn't need to know about module internals
-- Scales to any number of modules without server changes

package/templates/base/packages/api/package.json

@@ -1,35 +0,0 @@
-{
-	"name": "@__APP_NAME_KEBAB__/api",
-	"version": "0.0.1",
-	"private": true,
-	"type": "module",
-	"main": "src/index.ts",
-	"types": "src/index.ts",
-	"exports": {
-		".": {
-			"types": "./src/index.ts",
-			"default": "./src/index.ts"
-		},
-		"./*": {
-			"types": "./src/*.ts",
-			"default": "./src/*.ts"
-		}
-	},
-	"devDependencies": {
-		"@types/express": "^5.0.1"
-	},
-	"peerDependencies": {
-		"typescript": "^5"
-	},
-	"dependencies": {
-		"@orpc/server": "^1.10.0",
-		"@orpc/client": "^1.10.0",
-		"@orpc/zod": "^1.10.0",
-		"better-auth": "^1.3.28",
-		"dotenv": "^17.2.2",
-		"zod": "^4.1.11",
-		"awilix": "^12.0.5",
-		"@__APP_NAME_KEBAB__/auth": "workspace:*",
-		"@__APP_NAME_KEBAB__/db": "workspace:*"
-	}
-}

package/templates/base/packages/api/src/context.ts

@@ -1,48 +0,0 @@
-import type { Request } from 'express'
-import { fromNodeHeaders } from 'better-auth/node'
-import { auth } from '@__APP_NAME_KEBAB__/auth'
-import { asValue, type AwilixContainer } from 'awilix'
-
-declare global {
-	// eslint-disable-next-line @typescript-eslint/no-namespace
-	namespace Express {
-		interface Request {
-			scope?: AwilixContainer
-		}
-	}
-}
-
-export interface CreateContextOptions {
-	req: Request
-}
-
-/**
- * Create per-request context with DI container
- */
-export async function createContext(opts: CreateContextOptions) {
-	let session
-	try {
-		session = await auth.api.getSession({
-			headers: fromNodeHeaders(opts.req.headers),
-		})
-	} catch (error) {
-		console.error('[Auth] Failed to get session:', error)
-		session = null
-	}
-
-	const requestId = crypto.randomUUID()
-
-	if (opts.req.scope) {
-		opts.req.scope.register({
-			session: asValue(session),
-			requestId: asValue(requestId),
-		})
-	}
-
-	return {
-		session,
-		di: opts.req.scope!,
-	}
-}
-
-export type Context = Awaited<ReturnType<typeof createContext>>

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

@@ -1,22 +0,0 @@
-import { ORPCError, os } from '@orpc/server'
-import type { Context } from './context'
-
-export const o = os.$context<Context>()
-
-export const publicProcedure = o
-
-const requireAuth = o.middleware(async ({ context, next }) => {
-	if (!context.session?.user) {
-		throw new ORPCError('UNAUTHORIZED')
-	}
-	return next({
-		context: {
-			session: context.session,
-		},
-	})
-})
-
-export const protectedProcedure = publicProcedure.use(requireAuth)
-
-export { createContext } from './context'
-export type { Context } from './context'

package/templates/base/packages/api/tsconfig.json

@@ -1,8 +0,0 @@
-{
-	"extends": "../../tsconfig.base.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"rootDir": "src"
-	},
-	"include": ["src/**/*"]
-}

package/templates/base/packages/auth/AGENTS.md

@@ -1,61 +0,0 @@
-# AGENTS.md - Auth Package
-
-> See root [AGENTS.md](../../AGENTS.md) for SDK Module System patterns
-
-## Purpose
-
-Better-Auth configuration shared between server and web apps.
-
-## Key Files
-
-| File       | Purpose                                |
-| ---------- | -------------------------------------- |
-| `index.ts` | Auth configuration and client creation |
-
-## Server Usage
-
-```typescript
-import { auth } from '@__APP_NAME_KEBAB__/auth'
-
-// In Express
-app.all('/api/auth/*', auth.handler)
-```
-
-## Client Usage
-
-```typescript
-import { authClient } from '@__APP_NAME_KEBAB__/auth'
-
-// Sign in
-await authClient.signIn.email({ email, password })
-
-// Sign out
-await authClient.signOut()
-
-// Get session
-const session = await authClient.getSession()
-```
-
-## Session in oRPC Context
-
-The current user session is available in `protectedProcedure` handlers:
-
-```typescript
-import { protectedProcedure } from '@__APP_NAME_KEBAB__/api'
-
-export const myRouter = {
-	getProfile: protectedProcedure.handler(async ({ context }) => {
-		const userId = context.session?.user?.id
-		const userEmail = context.session?.user?.email
-		// ... use session data
-	}),
-}
-```
-
-## Configuration
-
-Auth requires these environment variables:
-
-- `BETTER_AUTH_SECRET` - Session encryption key
-- `BETTER_AUTH_URL` - Callback URL for OAuth
-- `DATABASE_URL` - For session storage

package/templates/base/packages/auth/package.json

@@ -1,27 +0,0 @@
-{
-	"name": "@__APP_NAME_KEBAB__/auth",
-	"version": "0.0.1",
-	"private": true,
-	"type": "module",
-	"main": "src/index.ts",
-	"types": "src/index.ts",
-	"exports": {
-		".": {
-			"types": "./src/index.ts",
-			"default": "./src/index.ts"
-		},
-		"./*": {
-			"types": "./src/*.ts",
-			"default": "./src/*.ts"
-		}
-	},
-	"peerDependencies": {
-		"typescript": "^5"
-	},
-	"dependencies": {
-		"better-auth": "^1.3.28",
-		"dotenv": "^17.2.2",
-		"zod": "^4.1.11",
-		"@__APP_NAME_KEBAB__/db": "workspace:*"
-	}
-}

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

@@ -1,22 +0,0 @@
-import { betterAuth, type BetterAuthOptions } from 'better-auth'
-import { drizzleAdapter } from 'better-auth/adapters/drizzle'
-import { db } from '@__APP_NAME_KEBAB__/db'
-import * as schema from '@__APP_NAME_KEBAB__/db/schema/auth'
-
-export const auth = betterAuth<BetterAuthOptions>({
-	database: drizzleAdapter(db, {
-		provider: 'pg',
-		schema: schema,
-	}),
-	trustedOrigins: [process.env.CORS_ORIGIN || ''],
-	emailAndPassword: {
-		enabled: true,
-	},
-	advanced: {
-		defaultCookieAttributes: {
-			sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
-			secure: process.env.NODE_ENV === 'production',
-			httpOnly: true,
-		},
-	},
-})

package/templates/base/packages/auth/tsconfig.json

@@ -1,8 +0,0 @@
-{
-	"extends": "../../tsconfig.base.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"rootDir": "src"
-	},
-	"include": ["src/**/*"]
-}