create-ely 0.1.1

package/templates/monorepo/apps/backend/src/db/migrations/meta/20251111132328_snapshot.json

@@ -0,0 +1,70 @@
+{
+  "id": "ae4e6c14-3efe-4132-b1c4-cc83dccf17d4",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "surname": {
+          "name": "surname",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/templates/monorepo/apps/backend/src/db/migrations/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1762867408207,
+      "tag": "20251111132328_curly_spectrum",
+      "breakpoints": true
+    }
+  ]
+}

package/templates/monorepo/apps/backend/src/db/schema/users.ts

@@ -0,0 +1,39 @@
+import { pgTable, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema,
+} from 'drizzle-typebox';
+import { t } from 'elysia';
+
+// Users table definition
+export const users = pgTable('users', {
+  id: uuid('id')
+    .primaryKey()
+    .$defaultFn(() => Bun.randomUUIDv7()),
+  name: varchar('name', { length: 255 }).notNull(),
+  surname: varchar('surname', { length: 255 }).notNull(),
+  email: varchar('email', { length: 255 }).notNull(),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+  updatedAt: timestamp('updated_at').notNull().defaultNow(),
+});
+
+// Field validation refinements for Elysia
+const fieldRefinements = {
+  name: t.String({ minLength: 1, maxLength: 255, examples: ['User Name'] }),
+  surname: t.String({
+    minLength: 1,
+    maxLength: 255,
+    examples: ['User Surname'],
+  }),
+  email: t.String({ minLength: 1, maxLength: 255, examples: ['User Email'] }),
+};
+
+// Drizzle-TypeBox schemas (declare variables to avoid infinite type instantiation)
+const _userCreate = createInsertSchema(users, fieldRefinements);
+const _userSelect = createSelectSchema(users, fieldRefinements);
+const _userUpdate = createUpdateSchema(users, fieldRefinements);
+
+export const userCreate = _userCreate;
+export const userSelect = _userSelect;
+export const userUpdate = _userUpdate;

package/templates/monorepo/apps/backend/src/main.ts

@@ -0,0 +1,67 @@
+import cors from '@elysiajs/cors';
+import openapi from '@elysiajs/openapi';
+import { Elysia } from 'elysia';
+import config from './common/config';
+import { log } from './common/logger';
+import { migrateDb } from './db';
+import { errorHandler } from './middleware/error-handler';
+import { users } from './modules/users';
+import { gracefulShutdown } from './util/graceful-shutdown';
+
+const app = new Elysia()
+  .use(cors())
+  .use(errorHandler)
+  .use(
+    openapi({
+      documentation: {
+        info: {
+          title: 'Elysia Boilerplate',
+          version: '0.1.5',
+          description: 'A simple boilerplate service for Elysia',
+        },
+        servers: [
+          {
+            url: `http://${config.SERVER_HOSTNAME}:${config.SERVER_PORT}`,
+            description: 'Local development server',
+          },
+        ],
+      },
+      enabled: config.ENABLE_OPENAPI,
+    }),
+  )
+  .use(users);
+
+/**
+ * Bootstrap the application.
+ * Runs all initialization tasks before starting the server.
+ */
+async function bootstrap(): Promise<void> {
+  // Run database migrations before accepting any requests
+  if (config.DB_AUTO_MIGRATE) {
+    await migrateDb();
+  }
+
+  // Start the server only after all initialization is complete
+  app.listen(config.SERVER_PORT, ({ development, hostname, port }) => {
+    log.info(
+      `🦊 Elysia is running at http://${hostname}:${port} ${development ? '🚧 in development mode!🚧' : ''}`,
+    );
+    if (config.ENABLE_OPENAPI) {
+      log.info(
+        `📚 OpenAPI documentation is available at http://${hostname}:${port}/openapi`,
+      );
+    } else {
+      log.info('📚 OpenAPI documentation is disabled');
+    }
+  });
+
+  process.once('SIGINT', () => gracefulShutdown(app, 'SIGINT'));
+  process.once('SIGTERM', () => gracefulShutdown(app, 'SIGTERM'));
+}
+
+bootstrap().catch((error) => {
+  log.fatal({ err: error }, 'Failed to start application');
+  process.exit(1);
+});
+
+export type App = typeof app;

package/templates/monorepo/apps/backend/src/middleware/error-handler.ts

@@ -0,0 +1,36 @@
+import { Elysia, ElysiaCustomStatusResponse, status } from 'elysia';
+import { log as logger } from 'src/common/logger';
+
+const log = logger.child({ name: 'error-handler' });
+
+/**
+ * Global error handling middleware
+ * Catches all unhandled errors and logs them
+ */
+export const errorHandler = new Elysia({ name: 'error-handler' }).onError(
+  ({ code, error, request }) => {
+    // Return Elysia's handled errors as-is
+    if (error instanceof ElysiaCustomStatusResponse || code !== 'UNKNOWN') {
+      return error;
+    }
+
+    // Log unhandled errors
+    log.error(
+      {
+        code,
+        err: error,
+        http: request
+          ? {
+              method: request.method,
+              url: request.url,
+              referrer: request.headers.get('referer') ?? undefined,
+            }
+          : undefined,
+      },
+      'Unhandled error',
+    );
+
+    // Do not expose unhandled errors to the client
+    return status(500, 'Internal Server Error');
+  },
+);

package/templates/monorepo/apps/backend/src/modules/users/index.ts

@@ -0,0 +1,61 @@
+import { Elysia, status } from 'elysia';
+import { log as logger } from 'src/common/logger';
+import { type UsersModel, usersModelPlugin } from './model';
+import { UsersService } from './service';
+
+const log = logger.child({ name: 'users' });
+
+export const users = new Elysia({ prefix: '/users', tags: ['Users'] })
+  .use(usersModelPlugin)
+  .post(
+    '/',
+    async ({ body }): Promise<UsersModel.createResponse> => {
+      try {
+        const user = await UsersService.create(body);
+        log.info(`Created user ${user.name}`);
+        return user;
+      } catch (error) {
+        log.error({ err: error }, 'Failed to create user');
+        throw status(422, {
+          message: 'Failed to create user' satisfies UsersModel.createError,
+        });
+      }
+    },
+    {
+      body: 'users.createRequest',
+      response: {
+        200: 'users.createResponse',
+        422: 'users.createError',
+      },
+      detail: {
+        summary: 'Create a new user',
+        description: 'Create a new user in the database with name and surname.',
+      },
+    },
+  )
+  .get(
+    '/',
+    async ({ query }): Promise<UsersModel.getResponse> => {
+      try {
+        const users = await UsersService.get(query);
+        log.info(`Got users ${users.total}`);
+        return users;
+      } catch (error) {
+        log.error({ err: error }, 'Failed to get users');
+        throw status(422, {
+          message: 'Failed to get users' satisfies UsersModel.getError,
+        });
+      }
+    },
+    {
+      query: 'users.getQuery',
+      response: {
+        200: 'users.getResponse',
+        422: 'users.getError',
+      },
+      detail: {
+        summary: 'Get all users',
+        description: 'Get all users from the database with name and surname.',
+      },
+    },
+  );

package/templates/monorepo/apps/backend/src/modules/users/model.ts

@@ -0,0 +1,48 @@
+import Elysia, { t } from 'elysia';
+import { userCreate, userSelect } from '../../db/schema/users';
+
+export namespace UsersModel {
+  // Create user
+  export const createRequest = t.Omit(userCreate, [
+    'id',
+    'createdAt',
+    'updatedAt',
+  ]);
+  export type createRequest = typeof createRequest.static;
+
+  export const createResponse = t.Omit(userSelect, ['createdAt', 'updatedAt']);
+  export type createResponse = typeof createResponse.static;
+
+  export const createError = t.Literal('Failed to create user');
+  export type createError = typeof createError.static;
+
+  // Get users
+  export const getQuery = t.Object({
+    limit: t.Number({
+      default: 100,
+      minimum: 1,
+      maximum: 100,
+      examples: [100],
+    }),
+    offset: t.Number({ default: 0, minimum: 0, examples: [0] }),
+  });
+  export type getQuery = typeof getQuery.static;
+
+  export const getResponse = t.Object({
+    users: t.Array(t.Omit(userSelect, ['createdAt', 'updatedAt'])),
+    total: t.Number(),
+  });
+  export type getResponse = typeof getResponse.static;
+
+  export const getError = t.Literal('Failed to get users');
+  export type getError = typeof getError.static;
+}
+
+export const usersModelPlugin = new Elysia().model({
+  'users.createRequest': UsersModel.createRequest,
+  'users.createResponse': UsersModel.createResponse,
+  'users.createError': UsersModel.createError,
+  'users.getQuery': UsersModel.getQuery,
+  'users.getResponse': UsersModel.getResponse,
+  'users.getError': UsersModel.getError,
+});

package/templates/monorepo/apps/backend/src/modules/users/service.ts

@@ -0,0 +1,46 @@
+import { count } from 'drizzle-orm';
+import { status } from 'elysia';
+import db from '../../db';
+import { users } from '../../db/schema/users';
+import type { UsersModel } from './model';
+
+export abstract class UsersService {
+  static async create(
+    body: UsersModel.createRequest,
+  ): Promise<UsersModel.createResponse> {
+    const [user] = await db
+      .insert(users)
+      .values({ ...body })
+      .returning();
+
+    if (!user) {
+      throw status(422, {
+        message: 'Failed to create user' satisfies UsersModel.createError,
+      });
+    }
+
+    return user;
+  }
+
+  static async get(
+    params: UsersModel.getQuery,
+  ): Promise<UsersModel.getResponse> {
+    const [total] = await db.select({ count: count() }).from(users);
+
+    const res = await db
+      .select({
+        id: users.id,
+        name: users.name,
+        surname: users.surname,
+        email: users.email,
+      })
+      .from(users)
+      .limit(params.limit)
+      .offset(params.offset);
+
+    return {
+      users: res,
+      total: total?.count ?? 0,
+    };
+  }
+}

package/templates/monorepo/apps/backend/src/tests/users.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test';
+import type { UsersModel } from 'src/modules/users/model';
+import { users } from '../modules/users/index';
+import { UsersService } from '../modules/users/service';
+
+// Mock the UsersService
+const mockUsersService = {
+  create: mock(() =>
+    Promise.resolve({
+      id: '0199477e-7aa7-7000-a65a-96e2efd46c10',
+      name: 'John',
+      surname: 'Doe',
+      email: 'john.doe@example.com',
+    }),
+  ),
+  get: mock(() =>
+    Promise.resolve({
+      users: [
+        {
+          id: '0199477e-7aa7-7000-a65a-96e2efd46c10',
+          name: 'John',
+          surname: 'Doe',
+          email: 'john.doe@example.com',
+        },
+      ],
+      total: 1,
+    }),
+  ),
+};
+
+// Mock the service methods
+Object.assign(UsersService, mockUsersService);
+
+describe('Users Module', () => {
+  beforeEach(() => {
+    mockUsersService.create.mockClear();
+    mockUsersService.get.mockClear();
+  });
+
+  describe('POST /users', () => {
+    it('should create a new user successfully', async () => {
+      const userData = {
+        name: 'John',
+        surname: 'Doe',
+        email: 'john.doe@example.com',
+      };
+
+      const response = await users.handle(
+        new Request('http://localhost/users', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(userData),
+        }),
+      );
+      expect(response.status).toBe(200);
+
+      const responseData = await response.json();
+      expect(responseData).toHaveProperty('id');
+      expect(responseData).toHaveProperty('name', 'John');
+      expect(responseData).toHaveProperty('surname', 'Doe');
+      expect(responseData).toHaveProperty('email', 'john.doe@example.com');
+
+      // Verify the service was called with correct data
+      expect(mockUsersService.create).toHaveBeenCalledWith(userData);
+    });
+
+    it('should return validation error for missing required fields', async () => {
+      const invalidUserData = {
+        name: 'John',
+        // missing surname and email
+      };
+
+      const response = await users.handle(
+        new Request('http://localhost/users', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(invalidUserData),
+        }),
+      );
+      expect(response.status).toBe(422);
+
+      expect(mockUsersService.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('GET /users', () => {
+    it('should get all users successfully', async () => {
+      const response = await users.handle(
+        new Request('http://localhost/users'),
+      );
+      expect(response.status).toBe(200);
+
+      const responseData = (await response.json()) as UsersModel.getResponse;
+      expect(responseData).toHaveProperty('users');
+      expect(responseData).toHaveProperty('total');
+      expect(Array.isArray(responseData.users)).toBe(true);
+      expect(typeof responseData.total).toBe('number');
+
+      expect(mockUsersService.get).toHaveBeenCalled();
+    });
+  });
+});

package/templates/monorepo/apps/backend/src/util/graceful-shutdown.ts

@@ -0,0 +1,37 @@
+import { log as logger } from 'src/common/logger';
+import db from 'src/db';
+import type { App } from 'src/main';
+
+const log = logger.child({ name: 'graceful-shutdown' });
+
+let isShuttingDown = false;
+
+export async function gracefulShutdown(
+  app: App,
+  signal: NodeJS.Signals,
+): Promise<void> {
+  if (isShuttingDown) {
+    log.warn('Already shutting down, ignoring signal');
+    return;
+  }
+
+  isShuttingDown = true;
+
+  log.info(`${signal} received, shutting down...`);
+
+  const shutdownTimeout = setTimeout(() => {
+    log.error('Shutdown timeout exceeded, forcing exit');
+    process.exit(1);
+  }, 10000); // 10 second timeout
+
+  try {
+    await app.stop();
+    await db.$client.end();
+    clearTimeout(shutdownTimeout);
+    process.exit(0);
+  } catch (error) {
+    clearTimeout(shutdownTimeout);
+    log.error(error, `Error during ${signal} shutdown`);
+    process.exit(1);
+  }
+}

package/templates/monorepo/apps/backend/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    // Paths
+    "baseUrl": "."
+  },
+
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/monorepo/apps/backend-biome.json.template

@@ -0,0 +1,14 @@
+{
+  "root": false,
+  "$schema": "https://biomejs.dev/schemas/2.3.10/schema.json",
+  "extends": ["../../biome.json"],
+  "files": {
+    "includes": [
+      "**/src/**/*",
+      "**/.vscode/**/*",
+      "**/drizzle.config.ts",
+      "**/tsconfig.json",
+      "!**/src/db/migrations/**/*"
+    ]
+  }
+}

package/templates/monorepo/apps/frontend/.env.example

@@ -0,0 +1 @@
+VITE_API_URL=http://localhost:3000

package/templates/monorepo/apps/frontend/README.md

@@ -0,0 +1,59 @@
+# Frontend Boilerplate
+
+React boilerplate for ElysiaJS full-stack applications.
+
+## Quick Start
+
+```bash
+bun install
+bun run dev     # Start dev server on port 5173
+bun run build   # Build for production
+```
+
+## Stack
+
+- **React 19** with TypeScript
+- **TanStack Router** - File-based routing in `src/routes/`
+- **Tailwind CSS** - Styling with v4
+- **Biome** - Linting & formatting
+- **Vitest** - Testing
+
+## Project Structure
+
+```
+src/
+├── features/        # Feature modules (e.g., layout)
+├── shared/          # Shared code
+│   ├── components/  # Reusable UI components
+│   ├── hooks/       # Custom hooks
+│   ├── utils/       # Utilities
+│   ├── types/       # Type definitions
+│   └── constants/   # App constants
+├── assets/          # Images, fonts, etc.
+├── routes/          # File-based routes
+└── main.tsx
+```
+
+## Commands
+
+```bash
+bun run dev        # Development server
+bun run build      # Production build
+bun run preview    # Preview production build
+bun run test       # Run tests
+bun run lint       # Lint code
+bun run format     # Format code
+bun run check      # Lint + format check
+```
+
+## Adding Routes
+
+Create a new file in `src/routes/` - TanStack Router handles the rest automatically.
+
+## Shadcn UI
+
+Add components:
+
+```bash
+bunx shadcn@latest add button
+```

package/templates/monorepo/apps/frontend/biome.json

@@ -0,0 +1,16 @@
+{
+  "root": false,
+  "$schema": "https://biomejs.dev/schemas/2.3.10/schema.json",
+  "extends": ["../../biome.json"],
+  "files": {
+    "includes": [
+      "**/src/**/*",
+      "**/.vscode/**/*",
+      "**/index.html",
+      "**/vite.config.js",
+      "!**/src/routeTree.gen.ts",
+      "!**/src/styles.css",
+      "!**/src/vite-env.d.ts"
+    ]
+  }
+}

package/templates/monorepo/apps/frontend/components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles.css",
+    "baseColor": "zinc",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}