@questpie/elysia 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+
+$ tsdown
+ℹ tsdown v0.18.4 powered by rolldown v1.0.0-beta.57
+ℹ config file: /Users/drepkovsky/questpie/repos/questpie-cms/packages/elysia/tsdown.config.ts 
+(node:61186) ExperimentalWarning: Type Stripping is an experimental feature and might change at any time
+(Use `node --trace-warnings ...` to show where the warning was created)
+ℹ entry: src/server.ts, src/client.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 4 files
+ℹ dist/server.mjs    1.53 kB │ gzip: 0.73 kB
+ℹ dist/client.mjs    1.20 kB │ gzip: 0.56 kB
+ℹ dist/server.d.mts  2.54 kB │ gzip: 0.96 kB
+ℹ dist/client.d.mts  1.60 kB │ gzip: 0.71 kB
+ℹ 4 files, total: 6.86 kB
+✔ Build complete in 5676ms

package/.turbo/turbo-check-types.log

@@ -0,0 +1 @@
+$ tsc --noEmit

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @questpie/elysia
+
+## 0.0.1
+
+### Patch Changes
+
+- feat: initial release
+- Updated dependencies
+  - questpie@0.0.1

package/README.md

@@ -0,0 +1,248 @@
+# @questpie/elysia
+
+Elysia adapter for QUESTPIE CMS with full end-to-end type safety using Eden Treaty.
+
+## Features
+
+- 🔒 **Full Type Safety**: End-to-end type safety using Elysia's Eden Treaty
+- 🚀 **High Performance**: Built on Elysia's blazing-fast framework
+- 🎯 **Auto-complete**: IntelliSense for all CMS routes and methods
+- 📦 **Zero Config**: Works out of the box with minimal setup
+
+## Installation
+
+```bash
+bun add @questpie/elysia @questpie/cms elysia
+```
+
+## Quick Start
+
+### Server Setup
+
+```typescript
+import { Elysia } from "elysia";
+import { questpieElysia } from "@questpie/elysia";
+import { cms } from "./cms";
+
+const app = new Elysia()
+	.use(questpieElysia(cms))
+	.listen(3000);
+
+console.log(`Server running at http://${app.server?.hostname}:${app.server?.port}`);
+
+// Export type for Eden Treaty client
+export type App = typeof app;
+```
+
+### Client Setup with Unified Client
+
+```typescript
+import { createClientFromEden } from "@questpie/elysia/client";
+import { cms } from "./cms";
+import type { App } from "./server";
+
+// IMPORTANT: Use `typeof cms` directly (not a type alias) for proper type inference
+const client = createClientFromEden<App, typeof cms>({
+	server: "localhost:3000",
+});
+
+// ✨ Use CMS CRUD operations (fully typed!)
+const posts = await client.collections.posts.find({ limit: 10 });
+
+// ✨ Use Eden Treaty for custom routes (fully type-safe!)
+const result = await client.api.custom.route.get();
+```
+
+## Configuration
+
+### Custom Options
+
+```typescript
+import { Elysia } from "elysia";
+import { questpieElysia } from "@questpie/elysia";
+import { cms } from "./cms";
+
+const app = new Elysia().use(
+	questpieElysia(cms, {
+		basePath: "/cms-api", // Default: '/cms'
+		cors: {
+			origin: "https://example.com",
+			credentials: true,
+		},
+	}),
+);
+```
+
+### Disable CORS
+
+```typescript
+const app = new Elysia().use(
+	questpieElysia(cms, {
+		cors: false, // Disable CORS middleware
+	}),
+);
+```
+
+## API Routes
+
+The adapter automatically creates the following routes:
+
+### Collections
+
+- `GET /cms/:collection` - Find all items
+- `POST /cms/:collection` - Create item
+- `GET /cms/:collection/:id` - Find one item
+- `PATCH /cms/:collection/:id` - Update item
+- `DELETE /cms/:collection/:id` - Delete item
+- `POST /cms/:collection/:id/restore` - Restore soft-deleted item
+
+### Globals
+
+- `GET /cms/globals/:global` - Get global settings
+- `PATCH /cms/globals/:global` - Update global settings
+
+### Storage
+
+- `POST /cms/storage/upload` - Upload file
+
+### Authentication
+
+- `ALL /cms/auth/*` - Better Auth routes
+
+## Type-Safe Client Examples
+
+### CRUD Operations
+
+```typescript
+import { createClientFromEden } from "@questpie/elysia/client";
+import { cms } from "./cms";
+import type { App } from "./server";
+
+// IMPORTANT: Use `typeof cms` directly for proper type inference
+const client = createClientFromEden<App, typeof cms>({
+	server: "localhost:3000",
+});
+
+// CMS CRUD operations (fully typed with autocomplete!)
+const posts = await client.collections.posts.find({
+	where: { published: true },
+	limit: 10,
+	orderBy: { createdAt: "desc" },
+});
+
+const newPost = await client.collections.posts.create({
+	title: "New Post",
+	content: "Content here",
+});
+
+const updated = await client.collections.posts.update("123", {
+	title: "Updated Title",
+});
+
+await client.collections.posts.delete("123");
+```
+
+### With Relations
+
+```typescript
+const post = await client.collections.posts.findOne({
+	where: { id: "123" },
+	with: {
+		author: true,
+		comments: true,
+	},
+});
+```
+
+### Custom Routes with Eden Treaty
+
+```typescript
+// Custom business logic routes are fully type-safe!
+const availability = await client.api.barbers[":id"].availability.get({
+	params: { id: "barber-123" },
+	query: { date: "2025-01-15" },
+});
+
+const booking = await client.api.appointments.book.post({
+	barberId: "123",
+	serviceId: "456",
+	scheduledAt: "2025-01-15T10:00:00Z",
+});
+```
+
+### File Upload
+
+```typescript
+const formData = new FormData();
+formData.append("file", file);
+
+const asset = await client.api.storage.upload.post(formData);
+```
+
+## Generic HTTP Client
+
+If you prefer a generic HTTP client (not Eden Treaty), use the shared client from `@questpie/cms`:
+
+```typescript
+import { createQCMSClient } from "@questpie/cms/client";
+import type { cms } from "./server";
+
+const client = createQCMSClient<typeof cms>({
+	baseURL: "http://localhost:3000",
+	basePath: "/cms",
+});
+
+// Still type-safe but uses fetch under the hood
+const posts = await client.collections.posts.find({ limit: 10 });
+```
+
+## Comparison with Hono
+
+### Elysia + Eden Treaty (Recommended)
+
+```typescript
+import { createClientFromEden } from "@questpie/elysia/client";
+import { cms } from "./cms";
+import type { App } from "./server";
+
+// Use `typeof cms` directly (not type alias!)
+const client = createClientFromEden<App, typeof cms>({
+	server: "localhost:3000",
+});
+
+// ✅ Fully type-safe end-to-end
+// ✅ Auto-complete for all routes and collections
+// ✅ Runtime type checking
+// ✅ CMS CRUD + custom routes in one client
+const posts = await client.collections.posts.find();
+const custom = await client.api.custom.route.get();
+```
+
+### Hono RPC
+
+```typescript
+import { createClientFromHono } from "@questpie/hono/client";
+import type { AppType } from "./server";
+import type { cms } from "./cms";
+
+const client = createClientFromHono<AppType, typeof cms>({
+	baseURL: "http://localhost:3000",
+});
+
+// ⚠️ Limited type safety for custom routes
+// ✅ Good CMS CRUD type safety
+// ✅ Single unified client
+const posts = await client.collections.posts.find();
+const custom = await client.api.custom.route.$get();
+```
+
+## Why Elysia?
+
+- **Better Type Safety**: Elysia with Eden Treaty provides superior end-to-end type safety compared to Hono
+- **Performance**: Elysia is one of the fastest JavaScript web frameworks
+- **Developer Experience**: Better IntelliSense and auto-complete
+- **Modern**: Built with TypeScript from the ground up
+
+## License
+
+MIT

package/dist/client.d.mts

@@ -0,0 +1,56 @@
+import Elysia from "elysia";
+import { Questpie } from "questpie";
+import { Treaty } from "@elysiajs/eden";
+import { QuestpieClient } from "questpie/client";
+
+//#region src/client.d.ts
+
+/**
+ * Elysia client configuration
+ */
+type ElysiaClientConfig = {
+  /**
+   * Server URL (domain with optional port, no protocol needed for Eden)
+   * @example 'localhost:3000'
+   * @example 'api.example.com'
+   */
+  server: string;
+  /**
+   * Custom fetch implementation
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Base path for CMS routes
+   * @default '/cms'
+   */
+  basePath?: string;
+  /**
+   * Default headers to include in all requests
+   */
+  headers?: Record<string, string>;
+};
+/**
+ * Create a unified client that combines QUESTPIE CMS CRUD operations
+ * with Elysia's native Eden Treaty client for custom routes
+ *
+ * @example
+ * ```ts
+ * import { createClientFromEden } from '@questpie/elysia/client'
+ * import type { App } from './server'
+ * import type { AppCMS } from './cms'
+ *
+ * const client = createClientFromEden<App, AppCMS>({
+ *   server: 'localhost:3000'
+ * })
+ *
+ * // Use CMS CRUD operations
+ * const posts = await client.collections.posts.find({ limit: 10 })
+ *
+ * // Use Eden Treaty for custom routes (fully type-safe!)
+ * const result = await client.api.custom.route.get()
+ * ```
+ */
+declare function createClientFromEden<TApp extends Elysia<any, any, any, any, any, any, any> = any, TCMS extends Questpie<any> = any>(config: ElysiaClientConfig): QuestpieClient<TCMS> & Treaty.Create<TApp>;
+//#endregion
+export { ElysiaClientConfig, createClientFromEden };

package/dist/client.mjs

@@ -0,0 +1,44 @@
+import { treaty } from "@elysiajs/eden";
+import { createQuestpieClient } from "questpie/client";
+
+//#region src/client.ts
+/**
+* Create a unified client that combines QUESTPIE CMS CRUD operations
+* with Elysia's native Eden Treaty client for custom routes
+*
+* @example
+* ```ts
+* import { createClientFromEden } from '@questpie/elysia/client'
+* import type { App } from './server'
+* import type { AppCMS } from './cms'
+*
+* const client = createClientFromEden<App, AppCMS>({
+*   server: 'localhost:3000'
+* })
+*
+* // Use CMS CRUD operations
+* const posts = await client.collections.posts.find({ limit: 10 })
+*
+* // Use Eden Treaty for custom routes (fully type-safe!)
+* const result = await client.api.custom.route.get()
+* ```
+*/
+function createClientFromEden(config) {
+	const cmsClient = createQuestpieClient({
+		baseURL: config.server.startsWith("http") ? config.server : `http://${config.server}`,
+		fetch: config.fetch,
+		basePath: config.basePath,
+		headers: config.headers
+	});
+	return {
+		...treaty(config.server, {
+			fetcher: config.fetch,
+			headers: config.headers
+		}),
+		collections: cmsClient.collections,
+		globals: cmsClient.globals
+	};
+}
+
+//#endregion
+export { createClientFromEden };

package/dist/server.d.mts

@@ -0,0 +1,122 @@
+import { Elysia as Elysia$1 } from "elysia";
+import { Questpie } from "questpie";
+
+//#region src/server.d.ts
+
+/**
+ * Context stored in Elysia decorator
+ */
+type QuestpieContext = {
+  cms: Questpie<any>;
+  cmsContext: Awaited<ReturnType<Questpie<any>["createContext"]>>;
+  user: any;
+};
+/**
+ * Elysia adapter configuration
+ */
+type ElysiaAdapterConfig = {
+  /**
+   * Base path for CMS routes
+   * Use '/cms' for server-only apps or '/api/cms' for fullstack apps.
+   * @default '/cms'
+   */
+  basePath?: string;
+};
+/**
+ * Create Elysia app with QUESTPIE CMS integration
+ *
+ * @example
+ * ```ts
+ * import { Elysia } from 'elysia'
+ * import { questpieElysia } from '@questpie/elysia'
+ * import { cms } from './cms'
+ *
+ * const app = new Elysia()
+ *   .use(questpieElysia(cms))
+ *
+ * export default app
+ * export type App = typeof app
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With custom config
+ * const app = new Elysia()
+ *   .use(questpieElysia(cms, {
+ *     basePath: '/cms-api',
+ *     cors: {
+ *       origin: 'https://example.com',
+ *       credentials: true
+ *     }
+ *   }))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Client usage with Eden Treaty
+ * import { treaty } from '@elysiajs/eden'
+ * import type { App } from './server'
+ *
+ * const client = treaty<App>('localhost:3000')
+ *
+ * // Fully type-safe!
+ * const posts = await client.cms.posts.get()
+ * const post = await client.cms.posts({ id: '123' }).get()
+ * const newPost = await client.cms.posts.post({ title: 'Hello' })
+ * ```
+ */
+declare function questpieElysia(cms: Questpie<any>, config?: ElysiaAdapterConfig): Elysia$1<string, {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {
+  [x: string]: {
+    "*": {
+      [x: string]: {
+        body: unknown;
+        params: {
+          "*": string;
+        } & {};
+        query: unknown;
+        headers: unknown;
+        response: {
+          200: Response;
+          422: {
+            type: "validation";
+            on: string;
+            summary?: string;
+            message?: string;
+            found?: unknown;
+            property?: string;
+            expected?: string;
+          };
+        };
+      };
+    };
+  };
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+//#endregion
+export { ElysiaAdapterConfig, QuestpieContext, questpieElysia };

package/dist/server.mjs

@@ -0,0 +1,66 @@
+import { Elysia as Elysia$1 } from "elysia";
+import { createFetchHandler } from "questpie";
+
+//#region src/server.ts
+/**
+* Create Elysia app with QUESTPIE CMS integration
+*
+* @example
+* ```ts
+* import { Elysia } from 'elysia'
+* import { questpieElysia } from '@questpie/elysia'
+* import { cms } from './cms'
+*
+* const app = new Elysia()
+*   .use(questpieElysia(cms))
+*
+* export default app
+* export type App = typeof app
+* ```
+*
+* @example
+* ```ts
+* // With custom config
+* const app = new Elysia()
+*   .use(questpieElysia(cms, {
+*     basePath: '/cms-api',
+*     cors: {
+*       origin: 'https://example.com',
+*       credentials: true
+*     }
+*   }))
+* ```
+*
+* @example
+* ```ts
+* // Client usage with Eden Treaty
+* import { treaty } from '@elysiajs/eden'
+* import type { App } from './server'
+*
+* const client = treaty<App>('localhost:3000')
+*
+* // Fully type-safe!
+* const posts = await client.cms.posts.get()
+* const post = await client.cms.posts({ id: '123' }).get()
+* const newPost = await client.cms.posts.post({ title: 'Hello' })
+* ```
+*/
+function questpieElysia(cms, config = {}) {
+	const basePath = config.basePath || "/cms";
+	const handler = createFetchHandler(cms, {
+		basePath,
+		accessMode: "user"
+	});
+	return new Elysia$1({
+		prefix: basePath,
+		name: "questpie-cms"
+	}).all("/*", async ({ request }) => {
+		return await handler(request) ?? new Response(JSON.stringify({ error: "Not found" }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+	});
+}
+
+//#endregion
+export { questpieElysia };

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@questpie/elysia",
+	"version": "0.0.1",
+	"type": "module",
+	"scripts": {
+		"build": "tsdown",
+		"check-types": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@elysiajs/cors": "^1.2.1",
+		"@elysiajs/eden": "^1.2.6",
+		"questpie": "workspace:*",
+		"elysia": "^1.2.14",
+		"qs": "^6.13.1"
+	},
+	"devDependencies": {
+		"@questpie/typescript-config": "workspace:*",
+		"@types/qs": "^6.9.17",
+		"bun-types": "latest",
+		"tsdown": "^0.18.3"
+	},
+	"peerDependencies": {
+		"questpie": "workspace:*"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/server.mjs",
+			"types": "./dist/server.d.mts"
+		},
+		"./client": {
+			"import": "./dist/client.mjs",
+			"types": "./dist/client.d.mts"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/client.ts

@@ -0,0 +1,86 @@
+import { treaty } from "@elysiajs/eden";
+import type { Treaty } from "@elysiajs/eden";
+import { createQuestpieClient, type QuestpieClient } from "questpie/client";
+import type { Questpie } from "questpie";
+import type Elysia from "elysia";
+
+/**
+ * Elysia client configuration
+ */
+export type ElysiaClientConfig = {
+	/**
+	 * Server URL (domain with optional port, no protocol needed for Eden)
+	 * @example 'localhost:3000'
+	 * @example 'api.example.com'
+	 */
+	server: string;
+
+	/**
+	 * Custom fetch implementation
+	 * @default globalThis.fetch
+	 */
+	fetch?: typeof fetch;
+
+	/**
+	 * Base path for CMS routes
+	 * @default '/cms'
+	 */
+	basePath?: string;
+
+	/**
+	 * Default headers to include in all requests
+	 */
+	headers?: Record<string, string>;
+};
+
+/**
+ * Create a unified client that combines QUESTPIE CMS CRUD operations
+ * with Elysia's native Eden Treaty client for custom routes
+ *
+ * @example
+ * ```ts
+ * import { createClientFromEden } from '@questpie/elysia/client'
+ * import type { App } from './server'
+ * import type { AppCMS } from './cms'
+ *
+ * const client = createClientFromEden<App, AppCMS>({
+ *   server: 'localhost:3000'
+ * })
+ *
+ * // Use CMS CRUD operations
+ * const posts = await client.collections.posts.find({ limit: 10 })
+ *
+ * // Use Eden Treaty for custom routes (fully type-safe!)
+ * const result = await client.api.custom.route.get()
+ * ```
+ */
+export function createClientFromEden<
+	TApp extends Elysia<any, any, any, any, any, any, any> = any,
+	TCMS extends Questpie<any> = any,
+>(config: ElysiaClientConfig): QuestpieClient<TCMS> & Treaty.Create<TApp> {
+	// Determine baseURL with protocol for CMS client
+	const baseURL = config.server.startsWith("http")
+		? config.server
+		: `http://${config.server}`;
+
+	// Create CMS client for CRUD operations
+	const cmsClient = createQuestpieClient<TCMS>({
+		baseURL,
+		fetch: config.fetch,
+		basePath: config.basePath,
+		headers: config.headers,
+	});
+
+	// Create Eden Treaty client for custom routes
+	const edenClient = treaty<TApp>(config.server, {
+		fetcher: config.fetch,
+		headers: config.headers,
+	});
+
+	// Merge both clients
+	return {
+		...edenClient,
+		collections: cmsClient.collections,
+		globals: cmsClient.globals,
+	} as QuestpieClient<TCMS> & Treaty.Create<TApp>;
+}