create-velox-app 0.4.6 → 0.4.9

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

@@ -0,0 +1,64 @@
+/**
+ * Application Entry Point - tRPC Hybrid Template
+ *
+ * VeloxTS hybrid API architecture:
+ * - tRPC at /trpc for type-safe frontend communication
+ * - REST at /api for external consumers
+ *
+ * Both APIs generated from the same procedure definitions.
+ */
+
+import 'dotenv/config';
+
+import { databasePlugin, serve, veloxApp } from '@veloxts/velox';
+
+import { config } from './config/app.js';
+import { prisma } from './config/database.js';
+import { healthProcedures } from './procedures/health.js';
+import { userProcedures } from './procedures/users.js';
+
+// ============================================================================
+// Application Bootstrap
+// ============================================================================
+
+const app = await veloxApp({
+  port: config.port,
+  host: config.host,
+  logger: config.logger,
+});
+
+await app.register(databasePlugin({ client: prisma }));
+
+// ============================================================================
+// API Registration
+// ============================================================================
+
+/**
+ * Serve procedures as both REST and tRPC endpoints
+ *
+ * - REST: /api/users, /api/health
+ * - tRPC: /trpc/users.getUser, /trpc/health.check
+ */
+const router = await serve(app, [healthProcedures, userProcedures], {
+  api: config.apiPrefix,
+  rpc: '/trpc',
+});
+
+// ============================================================================
+// Type Exports for Frontend
+// ============================================================================
+
+/**
+ * AppRouter type for frontend type safety
+ *
+ * @example
+ * ```typescript
+ * import type { AppRouter } from '../../api/src';
+ * import { createVeloxHooks } from '@veloxts/client/react';
+ *
+ * export const api = createVeloxHooks<AppRouter>();
+ * ```
+ */
+export type AppRouter = typeof router;
+
+await app.start();

package/src/templates/source/api/package.auth.json

@@ -23,6 +23,7 @@
     "bcrypt": "5.1.1",
     "better-sqlite3": "12.5.0",
     "dotenv": "17.2.3",
+    "file-uri-to-path": "2.0.0",
     "zod": "3.24.4"
   },
   "devDependencies": {

package/src/templates/source/api/package.default.json

@@ -22,6 +22,7 @@
     "@veloxts/velox": "__VELOXTS_VERSION__",
     "better-sqlite3": "12.5.0",
     "dotenv": "17.2.3",
+    "file-uri-to-path": "2.0.0",
     "zod": "3.24.4"
   },
   "devDependencies": {

package/src/templates/source/api/prisma.config.ts

@@ -5,6 +5,7 @@
  */
 
 import 'dotenv/config';
+
 import { defineConfig } from 'prisma/config';
 
 export default defineConfig({

package/src/templates/source/api/procedures/auth.ts

@@ -15,11 +15,11 @@ import {
   AuthError,
   authenticated,
   createAuthRateLimiter,
+  defineProcedures,
   hashPassword,
   jwtManager,
-  verifyPassword,
-  defineProcedures,
   procedure,
+  verifyPassword,
   z,
 } from '@veloxts/velox';
 
@@ -54,8 +54,14 @@ const rateLimiter = createAuthRateLimiter({
 // ============================================================================
 
 const COMMON_PASSWORDS = new Set([
-  'password', 'password123', '12345678', '123456789',
-  'qwerty123', 'letmein', 'welcome', 'admin123',
+  'password',
+  'password123',
+  '12345678',
+  '123456789',
+  'qwerty123',
+  'letmein',
+  'welcome',
+  'admin123',
 ]);
 
 // ============================================================================
@@ -127,7 +133,7 @@ const DUMMY_HASH = '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/X4.uy7dPSSXB5G6Uy
 // ============================================================================
 
 export const authProcedures = defineProcedures('auth', {
-  register: procedure()
+  createAccount: procedure()
     .rest({ method: 'POST', path: '/auth/register' })
     .use(rateLimiter.register())
     .input(RegisterInput)
@@ -165,7 +171,7 @@ export const authProcedures = defineProcedures('auth', {
       });
     }),
 
-  login: procedure()
+  createSession: procedure()
     .rest({ method: 'POST', path: '/auth/login' })
     .use(
       rateLimiter.login((ctx) => {
@@ -198,7 +204,7 @@ export const authProcedures = defineProcedures('auth', {
       });
     }),
 
-  refresh: procedure()
+  createRefresh: procedure()
     .rest({ method: 'POST', path: '/auth/refresh' })
     .use(rateLimiter.refresh())
     .input(RefreshInput)
@@ -247,7 +253,7 @@ export const authProcedures = defineProcedures('auth', {
       }
     }),
 
-  logout: procedure()
+  deleteSession: procedure()
     .rest({ method: 'POST', path: '/auth/logout' })
     .guard(authenticated)
     .output(LogoutResponse)

package/src/templates/source/api/procedures/health.ts

@@ -2,7 +2,7 @@
  * Health Check Procedures
  */
 
-import { VELOX_VERSION, defineProcedures, procedure, z } from '@veloxts/velox';
+import { defineProcedures, procedure, VELOX_VERSION, z } from '@veloxts/velox';
 
 export const healthProcedures = defineProcedures('health', {
   getHealth: procedure()

package/src/templates/source/api/procedures/users.auth.ts

@@ -2,62 +2,25 @@
  * User Procedures
  *
  * CRUD procedures for user management with authentication guards.
+ * Clean implementation without boilerplate:
+ * - No manual DbUser/DbClient interfaces needed
+ * - No toUserResponse() transformation needed
+ * - Output schema automatically serializes Date → string via withTimestamps()
  */
 
 import {
   AuthError,
   authenticated,
-  hasRole,
   defineProcedures,
   GuardError,
-  procedure,
+  hasRole,
+  NotFoundError,
   paginationInputSchema,
+  procedure,
   z,
 } from '@veloxts/velox';
 
-import {
-  CreateUserInput,
-  UpdateUserInput,
-  type User,
-  UserSchema,
-} from '../schemas/user.js';
-
-// ============================================================================
-// Database Types
-// ============================================================================
-
-interface DbUser {
-  id: string;
-  name: string;
-  email: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-interface DbClient {
-  user: {
-    findUnique: (args: { where: { id: string } }) => Promise<DbUser | null>;
-    findMany: (args?: { skip?: number; take?: number }) => Promise<DbUser[]>;
-    create: (args: { data: { name: string; email: string } }) => Promise<DbUser>;
-    update: (args: { where: { id: string }; data: { name?: string; email?: string } }) => Promise<DbUser>;
-    delete: (args: { where: { id: string } }) => Promise<DbUser>;
-    count: () => Promise<number>;
-  };
-}
-
-function getDb(ctx: { db: unknown }): DbClient {
-  return ctx.db as DbClient;
-}
-
-function toUserResponse(dbUser: DbUser): User {
-  return {
-    id: dbUser.id,
-    name: dbUser.name,
-    email: dbUser.email,
-    createdAt: dbUser.createdAt instanceof Date ? dbUser.createdAt.toISOString() : dbUser.createdAt,
-    updatedAt: dbUser.updatedAt instanceof Date ? dbUser.updatedAt.toISOString() : dbUser.updatedAt,
-  };
-}
+import { CreateUserInput, UpdateUserInput, UserSchema } from '../schemas/user.js';
 
 // ============================================================================
 // User Procedures
@@ -66,11 +29,14 @@ function toUserResponse(dbUser: DbUser): User {
 export const userProcedures = defineProcedures('users', {
   getUser: procedure()
     .input(z.object({ id: z.string().uuid() }))
-    .output(UserSchema.nullable())
+    .output(UserSchema)
     .query(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      const user = await db.user.findUnique({ where: { id: input.id } });
-      return user ? toUserResponse(user) : null;
+      const user = await ctx.db.user.findUnique({ where: { id: input.id } });
+      if (!user) {
+        throw new NotFoundError(`User with id '${input.id}' not found`);
+      }
+      // Return Prisma object directly - output schema handles Date serialization
+      return user;
     }),
 
   listUsers: procedure()
@@ -86,20 +52,17 @@ export const userProcedures = defineProcedures('users', {
       })
     )
     .query(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const page = input?.page ?? 1;
       const limit = input?.limit ?? 10;
       const skip = (page - 1) * limit;
 
-      const [dbUsers, total] = await Promise.all([
-        db.user.findMany({ skip, take: limit }),
-        db.user.count(),
+      const [users, total] = await Promise.all([
+        ctx.db.user.findMany({ skip, take: limit }),
+        ctx.db.user.count(),
       ]);
 
-      return {
-        data: dbUsers.map(toUserResponse),
-        meta: { page, limit, total },
-      };
+      // Return Prisma objects directly - output schema serializes dates
+      return { data: users, meta: { page, limit, total } };
     }),
 
   createUser: procedure()
@@ -107,9 +70,7 @@ export const userProcedures = defineProcedures('users', {
     .input(CreateUserInput)
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      const user = await db.user.create({ data: input });
-      return toUserResponse(user);
+      return ctx.db.user.create({ data: input });
     }),
 
   updateUser: procedure()
@@ -117,7 +78,6 @@ export const userProcedures = defineProcedures('users', {
     .input(z.object({ id: z.string().uuid() }).merge(UpdateUserInput))
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const { id, ...data } = input;
 
       if (!ctx.user) {
@@ -131,8 +91,7 @@ export const userProcedures = defineProcedures('users', {
         throw new GuardError('ownership', 'You can only update your own profile', 403);
       }
 
-      const updated = await db.user.update({ where: { id }, data });
-      return toUserResponse(updated);
+      return ctx.db.user.update({ where: { id }, data });
     }),
 
   patchUser: procedure()
@@ -140,7 +99,6 @@ export const userProcedures = defineProcedures('users', {
     .input(z.object({ id: z.string().uuid() }).merge(UpdateUserInput))
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const { id, ...data } = input;
 
       if (!ctx.user) {
@@ -154,8 +112,7 @@ export const userProcedures = defineProcedures('users', {
         throw new GuardError('ownership', 'You can only update your own profile', 403);
       }
 
-      const updated = await db.user.update({ where: { id }, data });
-      return toUserResponse(updated);
+      return ctx.db.user.update({ where: { id }, data });
     }),
 
   deleteUser: procedure()
@@ -163,8 +120,7 @@ export const userProcedures = defineProcedures('users', {
     .input(z.object({ id: z.string().uuid() }))
     .output(z.object({ success: z.boolean() }))
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      await db.user.delete({ where: { id: input.id } });
+      await ctx.db.user.delete({ where: { id: input.id } });
       return { success: true };
     }),
 });

package/src/templates/source/api/procedures/users.default.ts

@@ -1,53 +1,33 @@
 /**
  * User Procedures
+ *
+ * Clean implementation without boilerplate:
+ * - No manual DbUser/DbClient interfaces needed
+ * - No toUserResponse() transformation needed
+ * - Output schema automatically serializes Date → string via withTimestamps()
  */
 
-import { defineProcedures, procedure, paginationInputSchema, z } from '@veloxts/velox';
+import {
+  defineProcedures,
+  NotFoundError,
+  paginationInputSchema,
+  procedure,
+  z,
+} from '@veloxts/velox';
 
 import { CreateUserInput, UpdateUserInput, UserSchema } from '../schemas/user.js';
 
-// Database types
-interface DbUser {
-  id: string;
-  name: string;
-  email: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-interface DbClient {
-  user: {
-    findUnique: (args: { where: { id: string } }) => Promise<DbUser | null>;
-    findMany: (args?: { skip?: number; take?: number }) => Promise<DbUser[]>;
-    create: (args: { data: { name: string; email: string } }) => Promise<DbUser>;
-    update: (args: { where: { id: string }; data: { name?: string; email?: string } }) => Promise<DbUser>;
-    delete: (args: { where: { id: string } }) => Promise<DbUser>;
-    count: () => Promise<number>;
-  };
-}
-
-function getDb(ctx: { db: unknown }): DbClient {
-  return ctx.db as DbClient;
-}
-
-function toUserResponse(dbUser: DbUser) {
-  return {
-    id: dbUser.id,
-    name: dbUser.name,
-    email: dbUser.email,
-    createdAt: dbUser.createdAt.toISOString(),
-    updatedAt: dbUser.updatedAt.toISOString(),
-  };
-}
-
 export const userProcedures = defineProcedures('users', {
   getUser: procedure()
     .input(z.object({ id: z.string().uuid() }))
-    .output(UserSchema.nullable())
+    .output(UserSchema)
     .query(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      const user = await db.user.findUnique({ where: { id: input.id } });
-      return user ? toUserResponse(user) : null;
+      const user = await ctx.db.user.findUnique({ where: { id: input.id } });
+      if (!user) {
+        throw new NotFoundError(`User with id '${input.id}' not found`);
+      }
+      // Return Prisma object directly - output schema handles Date serialization
+      return user;
     }),
 
   listUsers: procedure()
@@ -63,57 +43,47 @@ export const userProcedures = defineProcedures('users', {
       })
     )
     .query(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const page = input?.page ?? 1;
       const limit = input?.limit ?? 10;
       const skip = (page - 1) * limit;
 
-      const [dbUsers, total] = await Promise.all([
-        db.user.findMany({ skip, take: limit }),
-        db.user.count(),
+      const [users, total] = await Promise.all([
+        ctx.db.user.findMany({ skip, take: limit }),
+        ctx.db.user.count(),
       ]);
 
-      return {
-        data: dbUsers.map(toUserResponse),
-        meta: { page, limit, total },
-      };
+      // Return Prisma objects directly - output schema serializes dates
+      return { data: users, meta: { page, limit, total } };
     }),
 
   createUser: procedure()
     .input(CreateUserInput)
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      const user = await db.user.create({ data: input });
-      return toUserResponse(user);
+      return ctx.db.user.create({ data: input });
     }),
 
   updateUser: procedure()
     .input(z.object({ id: z.string().uuid() }).merge(UpdateUserInput))
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const { id, ...data } = input;
-      const user = await db.user.update({ where: { id }, data });
-      return toUserResponse(user);
+      return ctx.db.user.update({ where: { id }, data });
     }),
 
   patchUser: procedure()
     .input(z.object({ id: z.string().uuid() }).merge(UpdateUserInput))
     .output(UserSchema)
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
       const { id, ...data } = input;
-      const user = await db.user.update({ where: { id }, data });
-      return toUserResponse(user);
+      return ctx.db.user.update({ where: { id }, data });
     }),
 
   deleteUser: procedure()
     .input(z.object({ id: z.string().uuid() }))
     .output(z.object({ success: z.boolean() }))
     .mutation(async ({ input, ctx }) => {
-      const db = getDb(ctx);
-      await db.user.delete({ where: { id: input.id } });
+      await ctx.db.user.delete({ where: { id: input.id } });
       return { success: true };
     }),
 });

package/src/templates/source/api/schemas/user.ts

@@ -1,17 +1,22 @@
 /**
  * User Schemas
+ *
+ * Uses withTimestamps() for automatic Date → string serialization.
+ * No manual transformation needed in procedure handlers.
  */
 
-import { createIdSchema, emailSchema, z } from '@veloxts/velox';
+import { createIdSchema, emailSchema, withTimestamps, z } from '@veloxts/velox';
 
-export const UserSchema = z.object({
+// Business fields only - timestamps added separately
+const UserFields = z.object({
   id: createIdSchema('uuid'),
   name: z.string().min(1).max(100),
   email: emailSchema,
-  createdAt: z.coerce.date().transform((d) => d.toISOString()),
-  updatedAt: z.coerce.date().transform((d) => d.toISOString()),
 });
 
+// Complete schema with automatic Date → string serialization
+export const UserSchema = withTimestamps(UserFields);
+
 export type User = z.infer<typeof UserSchema>;
 
 export const CreateUserInput = z.object({

package/src/templates/source/api/tsconfig.json

@@ -4,8 +4,9 @@
   "compilerOptions": {
     "rootDir": "./src",
     "outDir": "./dist",
-    "declaration": false,
-    "declarationMap": false
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]

package/src/templates/source/web/App.module.css

@@ -99,7 +99,9 @@
   border: 1px solid #222;
   border-radius: 12px;
   padding: 1.5rem;
-  transition: border-color 0.2s, transform 0.2s;
+  transition:
+    border-color 0.2s,
+    transform 0.2s;
 }
 
 .card:hover {
@@ -217,7 +219,9 @@
   font-size: 1rem;
   font-weight: 600;
   cursor: pointer;
-  transition: opacity 0.2s, transform 0.1s;
+  transition:
+    opacity 0.2s,
+    transform 0.1s;
 }
 
 .button:hover {
@@ -247,6 +251,54 @@
   margin-top: 0.5rem;
 }
 
+/* Table */
+.tableContainer {
+  background: #111;
+  border: 1px solid #222;
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.table th,
+.table td {
+  padding: 1rem 1.5rem;
+  text-align: left;
+}
+
+.table th {
+  background: #0a0a0a;
+  color: #888;
+  font-weight: 600;
+  font-size: 0.85rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  border-bottom: 1px solid #222;
+}
+
+.table td {
+  color: #fff;
+  border-bottom: 1px solid #1a1a1a;
+}
+
+.table tbody tr:hover {
+  background: #1a1a1a;
+}
+
+.table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.emptyState {
+  text-align: center;
+  color: #666;
+  padding: 2rem !important;
+}
+
 /* Responsive */
 @media (max-width: 768px) {
   .nav {

package/src/templates/source/web/api.ts

@@ -0,0 +1,42 @@
+/**
+ * VeloxTS API Hooks
+ *
+ * This file creates typed hooks for accessing your backend procedures.
+ * Import `api` in your components for full autocomplete support.
+ *
+ * @example
+ * ```tsx
+ * import { api } from '@/api';
+ * import { useQueryClient } from '@veloxts/client/react';
+ *
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const queryClient = useQueryClient();
+ *
+ *   const { data: user } = api.users.getUser.useQuery({ id: userId });
+ *   const { mutate } = api.users.updateUser.useMutation({
+ *     onSuccess: () => api.users.getUser.invalidate({ id: userId }, queryClient),
+ *   });
+ * }
+ * ```
+ */
+
+import { createVeloxHooks } from '@veloxts/client/react';
+
+import type { AppRouter } from '../../api/src/index.js';
+
+/**
+ * Type-safe API hooks with full autocomplete
+ *
+ * Hooks (call inside components):
+ * - api.namespace.procedure.useQuery(input, options)
+ * - api.namespace.procedure.useMutation(options)
+ * - api.namespace.procedure.useSuspenseQuery(input, options)
+ *
+ * Cache utilities (input first, queryClient last):
+ * - api.namespace.procedure.getQueryKey(input)
+ * - api.namespace.procedure.invalidate(input, queryClient)
+ * - api.namespace.procedure.prefetch(input, queryClient)
+ * - api.namespace.procedure.getData(input, queryClient)
+ * - api.namespace.procedure.setData(input, data, queryClient)
+ */
+export const api = createVeloxHooks<AppRouter>();