create-velox-app 0.6.84 → 0.6.86

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # create-velox-app
 
+## 0.6.86
+
+### Patch Changes
+
+- updated documentation
+
+## 0.6.85
+
+### Patch Changes
+
+- implement missing features from original requirements
+
 ## 0.6.84
 
 ### Patch Changes

package/GUIDE.md

@@ -17,9 +17,10 @@ Your app will be running at `http://localhost:3030`
 
 ```bash
 npx create-velox-app my-app              # Default REST API
-npx create-velox-app my-app --auth       # With authentication
-npx create-velox-app my-app --trpc       # tRPC-only setup
-npx create-velox-app my-app --rsc        # Full-stack setup with React Server Components
+npx create-velox-app my-app --auth       # With JWT authentication
+npx create-velox-app my-app --trpc       # tRPC-only setup (no REST)
+npx create-velox-app my-app --rsc        # Full-stack RSC with Vinxi
+npx create-velox-app my-app --rsc-auth   # Full-stack RSC + JWT authentication
 ```
 
 ## Project Structure

package/dist/templates/trpc.d.ts

@@ -1,14 +1,16 @@
 /**
- * tRPC Hybrid Template (Full-Stack)
+ * tRPC Template (Full-Stack)
  *
  * Full-stack workspace template with:
- * - apps/api: Hybrid tRPC + REST API with user CRUD operations
+ * - apps/api: tRPC-only API with user CRUD operations
  * - apps/web: React frontend with TanStack Router
  *
  * Showcases VeloxTS's type-safe frontend-backend communication:
- * - tRPC endpoints for internal consumption (primary)
- * - REST endpoints for external APIs (auto-generated)
+ * - tRPC endpoints only (no REST)
  * - End-to-end type safety without code generation
+ * - Frontend imports types directly from router.ts
+ *
+ * For REST + tRPC hybrid, use --default template and add registerRpc().
  */
 import type { TemplateConfig, TemplateFile } from './types.js';
 export declare function generateTrpcTemplate(config: TemplateConfig): TemplateFile[];

package/dist/templates/trpc.js

@@ -1,14 +1,16 @@
 /**
- * tRPC Hybrid Template (Full-Stack)
+ * tRPC Template (Full-Stack)
  *
  * Full-stack workspace template with:
- * - apps/api: Hybrid tRPC + REST API with user CRUD operations
+ * - apps/api: tRPC-only API with user CRUD operations
  * - apps/web: React frontend with TanStack Router
  *
  * Showcases VeloxTS's type-safe frontend-backend communication:
- * - tRPC endpoints for internal consumption (primary)
- * - REST endpoints for external APIs (auto-generated)
+ * - tRPC endpoints only (no REST)
  * - End-to-end type safety without code generation
+ * - Frontend imports types directly from router.ts
+ *
+ * For REST + tRPC hybrid, use --default template and add registerRpc().
  */
 import { compileTemplate } from './compiler.js';
 import { applyDatabaseDependencies, DEFAULT_CONFIG, TRPC_CONFIG } from './placeholders.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-velox-app",
-  "version": "0.6.84",
+  "version": "0.6.86",
   "description": "Project scaffolder for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",

package/src/templates/source/api/index.trpc.ts

@@ -1,11 +1,11 @@
 /**
- * Application Entry Point - tRPC Hybrid Template
+ * Application Entry Point - tRPC Template
  *
- * VeloxTS hybrid API architecture:
+ * VeloxTS tRPC-only API architecture:
  * - tRPC at /trpc for type-safe frontend communication
- * - REST at /api for external consumers
+ * - No REST endpoints (use --default template for REST)
  *
- * Both APIs generated from the same procedure definitions.
+ * Frontend imports types directly from router.ts for full type safety.
  */
 
 import 'dotenv/config';
@@ -13,15 +13,13 @@ import 'dotenv/config';
 // Side-effect import for declaration merging (extends ctx.db type)
 import './types.js';
 
-import { databasePlugin, serve, veloxApp } from '@veloxts/velox';
+import { databasePlugin, registerRpc, veloxApp } from '@veloxts/velox';
 
 import { config } from './config/app.js';
 import { db } from './config/database.js';
-// Import router definition (type-only safe for frontend imports)
 import { collections } from './router.js';
 
-// Re-export AppRouter for backward compatibility
-// Frontend should import from ./router.js directly for type safety
+// Re-export AppRouter for frontend type imports
 export type { AppRouter } from './router.js';
 
 // ============================================================================
@@ -37,19 +35,18 @@ const app = await veloxApp({
 await app.register(databasePlugin({ client: db }));
 
 // ============================================================================
-// API Registration
+// tRPC Registration
 // ============================================================================
 
 /**
- * Serve procedures as both REST and tRPC endpoints
+ * Register tRPC routes at /trpc
  *
- * - REST: /api/users, /api/health
- * - tRPC: /trpc/users.getUser, /trpc/health.getHealth
+ * Endpoints: /trpc/users.listUsers, /trpc/health.getHealth, etc.
+ *
+ * No REST endpoints - this template is for internal TypeScript clients only.
+ * For REST + tRPC hybrid, use the --default template and add registerRpc().
  */
-await serve(app, collections, {
-  api: config.apiPrefix,
-  rpc: '/trpc',
-});
+await registerRpc(app, collections, { prefix: '/trpc' });
 
 await app.start();
 

package/src/templates/source/api/router.trpc.ts

@@ -1,7 +1,7 @@
 /**
  * Router Definition - tRPC Hybrid Template
  *
- * This file exports the router type for frontend type safety.
+ * This file exports the typed tRPC router for frontend type safety.
  * It MUST NOT have any side effects (like importing dotenv) so that
  * the frontend can safely import types from here.
  *
@@ -14,26 +14,52 @@
 // This is NOT a runtime import - it only affects type checking.
 /// <reference path="./types.ts" />
 
-import { createRouter } from '@veloxts/velox';
+import { rpc } from '@veloxts/velox';
 
 import { healthProcedures } from './procedures/health.js';
 import { userProcedures } from './procedures/users.js';
 
-// Create router and collections from procedure definitions
-export const { collections, router } = createRouter(healthProcedures, userProcedures);
+/**
+ * Procedure collections for REST and tRPC registration
+ *
+ * IMPORTANT: Use `as const` to preserve literal types for full type inference.
+ */
+export const collections = [healthProcedures, userProcedures] as const;
+
+/**
+ * Create typed tRPC router using the rpc() helper
+ *
+ * The rpc() helper returns:
+ * - `router`: Fully typed tRPC router for client type inference
+ * - `register`: Async function to register tRPC routes with Fastify
+ *
+ * NOTE: `register` is not exported to avoid TypeScript portability issues.
+ * Use registerRpc() in index.ts instead.
+ */
+const { router } = rpc(collections, { prefix: '/trpc' });
+
+/**
+ * Typed tRPC router for client imports
+ *
+ * Use this for type-safe frontend-backend communication.
+ */
+export { router };
 
 /**
  * AppRouter type for frontend type safety
  *
- * Constructed from procedure collections to preserve full type information.
- * This enables type-safe API calls with full autocomplete.
+ * This is the properly typed tRPC router that enables:
+ * - Full autocomplete for procedure names
+ * - Type-safe input validation
+ * - Inferred output types
  *
  * @example
  * ```typescript
  * import type { AppRouter } from '../../api/src/router.js';
- * import { createVeloxHooks } from '@veloxts/client/react';
+ * import { createTRPCClient } from '@trpc/client';
  *
- * export const api = createVeloxHooks<AppRouter>();
+ * const client = createTRPCClient<AppRouter>({ links: [...] });
+ * const users = await client.users.listUsers.query(); // Fully typed!
  * ```
  */
 export type AppRouter = typeof router;