@beignet/cli 0.0.4 → 0.0.6

package/dist/templates/shell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.js","sourceRoot":"","sources":["../../src/templates/shell.ts"],"names":[],"mappings":"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"}

package/dist/templates/todos.d.ts

@@ -0,0 +1,17 @@
+declare const files: {
+    schemas: string;
+    contracts: string;
+    ports: string;
+    policy: string;
+    routes: string;
+    listTodosUseCase: string;
+    createTodoUseCase: string;
+    updateTodoUseCase: string;
+    deleteTodoUseCase: string;
+    useCasesIndex: string;
+    testHelpers: string;
+    useCaseTest: string;
+    routesTest: string;
+};
+export { files as todosFiles };
+//# sourceMappingURL=todos.d.ts.map

package/dist/templates/todos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todos.d.ts","sourceRoot":"","sources":["../../src/templates/todos.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;CA4lBV,CAAC;AAEF,OAAO,EAAE,KAAK,IAAI,UAAU,EAAE,CAAC"}

package/dist/templates/todos.js

@@ -0,0 +1,607 @@
+const files = {
+    schemas: `import { z } from "zod";
+
+export const TodoSchema = z.object({
+	id: z.string().uuid(),
+	userId: z.string(),
+	title: z.string().min(1),
+	completed: z.boolean(),
+	createdAt: z.string().datetime(),
+});
+
+export const ListTodosInputSchema = z.object({
+	limit: z.coerce.number().int().min(1).max(100).default(20),
+	offset: z.coerce.number().int().min(0).default(0),
+});
+
+export const ListTodosOutputSchema = z.object({
+	items: z.array(TodoSchema),
+	page: z.object({
+		kind: z.literal("offset"),
+		limit: z.number().int().min(1),
+		offset: z.number().int().min(0),
+		total: z.number().int().min(0),
+		hasMore: z.boolean(),
+	}),
+});
+
+export const TodoIdInputSchema = z.object({
+	id: z.string().uuid(),
+});
+
+export const CreateTodoInputSchema = z.object({
+	title: z.string().min(1).max(120),
+});
+
+export const UpdateTodoBodySchema = z.object({
+	completed: z.boolean(),
+});
+
+export const UpdateTodoInputSchema = TodoIdInputSchema.merge(
+	UpdateTodoBodySchema,
+);
+
+export const DeleteTodoOutputSchema = z.void();
+
+export type Todo = z.infer<typeof TodoSchema>;
+export type CreateTodoInput = z.infer<typeof CreateTodoInputSchema>;
+export type ListTodosInput = z.infer<typeof ListTodosInputSchema>;
+export type UpdateTodoInput = z.infer<typeof UpdateTodoInputSchema>;
+`,
+    contracts: `import { defineContractGroup } from "@beignet/core/contracts";
+import { z } from "zod";
+import { errors } from "@/features/shared/errors";
+import {
+	CreateTodoInputSchema,
+	ListTodosOutputSchema,
+	TodoIdInputSchema,
+	TodoSchema,
+	UpdateTodoBodySchema,
+} from "@/features/todos/schemas";
+
+const ErrorResponseSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	requestId: z.string().optional(),
+});
+
+const todos = defineContractGroup()
+	.namespace("todos")
+	.errors({ Unauthorized: errors.Unauthorized })
+	.responses({
+		500: ErrorResponseSchema,
+	});
+
+export const listTodos = todos.get("/api/todos").responses({
+	200: ListTodosOutputSchema,
+});
+
+export const createTodo = todos
+	.post("/api/todos")
+	.body(CreateTodoInputSchema)
+	.meta({ idempotency: { header: "idempotency-key", scope: "actor" } })
+	.errors({ Forbidden: errors.Forbidden })
+	.responses({
+		201: TodoSchema,
+	});
+
+export const updateTodo = todos
+	.patch("/api/todos/:id")
+	.pathParams(TodoIdInputSchema)
+	.body(UpdateTodoBodySchema)
+	.errors({
+		Forbidden: errors.Forbidden,
+		TodoNotFound: errors.TodoNotFound,
+	})
+	.responses({
+		200: TodoSchema,
+	});
+
+export const deleteTodo = todos
+	.delete("/api/todos/:id")
+	.pathParams(TodoIdInputSchema)
+	.errors({
+		Forbidden: errors.Forbidden,
+		TodoNotFound: errors.TodoNotFound,
+	})
+	.responses({
+		204: null,
+	});
+`,
+    ports: `import type {
+	OffsetPage,
+	OffsetPageInfo,
+	PageResult,
+} from "@beignet/core/pagination";
+import type { Todo } from "@/features/todos/schemas";
+
+export type ListTodosResult = PageResult<Todo, OffsetPageInfo>;
+
+export type NewTodo = {
+	userId: string;
+	title: string;
+};
+
+export type UpdateTodoData = {
+	completed: boolean;
+};
+
+export interface TodoRepository {
+	list(userId: string, page: OffsetPage): Promise<ListTodosResult>;
+	findById(id: string): Promise<Todo | null>;
+	create(input: NewTodo): Promise<Todo>;
+	update(id: string, input: UpdateTodoData): Promise<Todo>;
+	delete(id: string): Promise<void>;
+}
+`,
+    policy: `import { type ActivityActor, definePolicy, deny } from "@beignet/core/ports";
+import type { Todo } from "@/features/todos/schemas";
+import type { AuthSession } from "@/ports/auth";
+
+export type AuthorizationContext = {
+	actor: ActivityActor;
+	auth: AuthSession | null;
+};
+
+function authorizeOwner(
+	ctx: AuthorizationContext,
+	todo: Todo,
+	action: "update" | "delete",
+) {
+	if (ctx.actor.type !== "user") {
+		return deny(\`You must be signed in to \${action} todos.\`);
+	}
+
+	if (todo.userId !== ctx.actor.id) {
+		return deny({
+			reason: \`Only the owner can \${action} this todo.\`,
+			code: "NOT_TODO_OWNER",
+			details: { todoId: todo.id },
+		});
+	}
+
+	return true;
+}
+
+export const todoPolicy = definePolicy({
+	"todos.create": (ctx: AuthorizationContext) => {
+		if (ctx.actor.type === "user") return true;
+		return deny("You must be signed in to create todos.");
+	},
+	"todos.update": (ctx: AuthorizationContext, todo: Todo) =>
+		authorizeOwner(ctx, todo, "update"),
+	"todos.delete": (ctx: AuthorizationContext, todo: Todo) =>
+		authorizeOwner(ctx, todo, "delete"),
+});
+`,
+    routes: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "@/app-context";
+import {
+	createTodo,
+	deleteTodo,
+	listTodos,
+	updateTodo,
+} from "@/features/todos/contracts";
+import {
+	createTodoUseCase,
+	deleteTodoUseCase,
+	listTodosUseCase,
+	updateTodoUseCase,
+} from "@/features/todos/use-cases";
+
+export const todoRoutes = defineRouteGroup<AppContext>({
+	name: "todos",
+	routes: [
+		{ contract: listTodos, useCase: listTodosUseCase },
+		{ contract: createTodo, useCase: createTodoUseCase },
+		{ contract: updateTodo, useCase: updateTodoUseCase },
+		{ contract: deleteTodo, useCase: deleteTodoUseCase },
+	],
+});
+`,
+    listTodosUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { normalizeOffsetPage } from "@beignet/core/pagination";
+import { requireUser } from "@/lib/auth";
+import { useCase } from "@/lib/use-case";
+import { ListTodosInputSchema, ListTodosOutputSchema } from "../schemas";
+
+export const listTodosUseCase = useCase
+	.query("todos.list")
+	.input(ListTodosInputSchema)
+	.output(ListTodosOutputSchema)
+	.run(async ({ ctx, input }) => {
+		const user = requireUser(ctx);
+		const page = normalizeOffsetPage(input, {
+			defaultLimit: 20,
+			maxLimit: 100,
+		});
+
+		return ctx.ports.todos.list(user.id, page);
+	});
+`,
+    createTodoUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { requireUser } from "@/lib/auth";
+import { useCase } from "@/lib/use-case";
+import { CreateTodoInputSchema, TodoSchema } from "../schemas";
+
+export const createTodoUseCase = useCase
+	.command("todos.create")
+	.input(CreateTodoInputSchema)
+	.output(TodoSchema)
+	.run(async ({ ctx, input }) => {
+		const user = requireUser(ctx);
+		await ctx.gate.authorize("todos.create");
+
+		return ctx.ports.uow.transaction(async (tx) =>
+			tx.todos.create({ userId: user.id, title: input.title }),
+		);
+	});
+`,
+    updateTodoUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { appError } from "@/features/shared/errors";
+import { requireUser } from "@/lib/auth";
+import { useCase } from "@/lib/use-case";
+import { TodoSchema, UpdateTodoInputSchema } from "../schemas";
+
+export const updateTodoUseCase = useCase
+	.command("todos.update")
+	.input(UpdateTodoInputSchema)
+	.output(TodoSchema)
+	.run(async ({ ctx, input }) => {
+		requireUser(ctx);
+
+		return ctx.ports.uow.transaction(async (tx) => {
+			const todo = await tx.todos.findById(input.id);
+			if (!todo) {
+				throw appError("TodoNotFound", { details: { id: input.id } });
+			}
+
+			await ctx.gate.authorize("todos.update", todo);
+
+			return tx.todos.update(input.id, { completed: input.completed });
+		});
+	});
+`,
+    deleteTodoUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { appError } from "@/features/shared/errors";
+import { requireUser } from "@/lib/auth";
+import { useCase } from "@/lib/use-case";
+import { DeleteTodoOutputSchema, TodoIdInputSchema } from "../schemas";
+
+export const deleteTodoUseCase = useCase
+	.command("todos.delete")
+	.input(TodoIdInputSchema)
+	.output(DeleteTodoOutputSchema)
+	.run(async ({ ctx, input }) => {
+		requireUser(ctx);
+
+		await ctx.ports.uow.transaction(async (tx) => {
+			const todo = await tx.todos.findById(input.id);
+			if (!todo) {
+				throw appError("TodoNotFound", { details: { id: input.id } });
+			}
+
+			await ctx.gate.authorize("todos.delete", todo);
+
+			await tx.todos.delete(input.id);
+		});
+	});
+`,
+    useCasesIndex: `export { createTodoUseCase } from "./create-todo";
+export { deleteTodoUseCase } from "./delete-todo";
+export { listTodosUseCase } from "./list-todos";
+export { updateTodoUseCase } from "./update-todo";
+export {
+	CreateTodoInputSchema,
+	ListTodosInputSchema,
+	ListTodosOutputSchema,
+	TodoIdInputSchema,
+	TodoSchema,
+	UpdateTodoInputSchema,
+	type CreateTodoInput,
+	type ListTodosInput,
+	type Todo,
+	type UpdateTodoInput,
+} from "../schemas";
+`,
+    testHelpers: `import type { OffsetPage } from "@beignet/core/pagination";
+import { offsetPageResult } from "@beignet/core/pagination";
+import type {
+	NewTodo,
+	TodoRepository,
+	UpdateTodoData,
+} from "@/features/todos/ports";
+import type { Todo } from "@/features/todos/schemas";
+
+export function createTestTodoRepository(): TodoRepository {
+	const todos = new Map<string, Todo>();
+
+	return {
+		async list(userId: string, page: OffsetPage) {
+			const owned = Array.from(todos.values())
+				.filter((todo) => todo.userId === userId)
+				.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+
+			return offsetPageResult(
+				owned.slice(page.offset, page.offset + page.limit),
+				page,
+				owned.length,
+			);
+		},
+		async findById(id: string) {
+			return todos.get(id) ?? null;
+		},
+		async create(input: NewTodo) {
+			const todo: Todo = {
+				id: crypto.randomUUID(),
+				userId: input.userId,
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			todos.set(todo.id, todo);
+			return todo;
+		},
+		async update(id: string, input: UpdateTodoData) {
+			const todo = todos.get(id);
+			if (!todo) {
+				throw new Error(\`Todo not found: \${id}\`);
+			}
+
+			const next = { ...todo, completed: input.completed };
+			todos.set(id, next);
+			return next;
+		},
+		async delete(id: string) {
+			todos.delete(id);
+		},
+	};
+}
+`,
+    useCaseTest: `import { describe, expect, it } from "bun:test";
+import { createUseCaseTester } from "@beignet/core/application";
+import { createTestUserActor } from "@beignet/core/ports/testing";
+import {
+	createTestContextFactory,
+	createTestPorts,
+} from "@beignet/core/testing";
+import { createInMemoryDevtools } from "@beignet/devtools";
+import type { AppContext } from "@/app-context";
+import type { TodoRepository } from "@/features/todos/ports";
+import { appPorts } from "@/infra/app-ports";
+import type { AppTransactionPorts } from "@/ports";
+import {
+	createTodoUseCase,
+	deleteTodoUseCase,
+	listTodosUseCase,
+	updateTodoUseCase,
+} from "../use-cases";
+import { createTestTodoRepository } from "./helpers";
+
+function createTester(userId: string, todos: TodoRepository) {
+	const auth = {
+		user: {
+			id: userId,
+			email: \`\${userId}@example.com\`,
+			name: "Test User",
+		},
+		session: { id: \`session_\${userId}\` },
+	};
+	const testFixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
+		base: appPorts,
+		overrides: {
+			gate: appPorts.gate,
+			todos,
+			devtools: createInMemoryDevtools(),
+		},
+		transaction: {
+			ports: (ports) => ({
+				...ports,
+				todos,
+			}),
+		},
+	});
+	const createTestContext = createTestContextFactory<
+		AppContext,
+		AppContext["ports"]
+	>({
+		ports: testFixture.ports,
+		actor: createTestUserActor(auth.user.id, {
+			displayName: auth.user.name,
+		}),
+		auth,
+	});
+
+	return createUseCaseTester<AppContext>(createTestContext);
+}
+
+describe("todos use cases", () => {
+	it("creates, lists, updates, and deletes the signed-in user's todos", async () => {
+		const todos = createTestTodoRepository();
+		const tester = createTester("user_test", todos);
+		const ctx = await tester.ctx();
+
+		const created = await tester.run(
+			createTodoUseCase,
+			{ title: "First todo" },
+			{ ctx },
+		);
+		const updated = await tester.run(
+			updateTodoUseCase,
+			{ id: created.id, completed: true },
+			{ ctx },
+		);
+		const listed = await tester.run(
+			listTodosUseCase,
+			{ limit: 20, offset: 0 },
+			{ ctx },
+		);
+
+		expect(created.userId).toBe("user_test");
+		expect(updated.completed).toBe(true);
+		expect(listed.page.total).toBe(1);
+		expect(listed.items).toEqual([updated]);
+
+		await tester.run(deleteTodoUseCase, { id: created.id }, { ctx });
+		const afterDelete = await tester.run(
+			listTodosUseCase,
+			{ limit: 20, offset: 0 },
+			{ ctx },
+		);
+
+		expect(afterDelete.page.total).toBe(0);
+	});
+
+	it("denies updates to todos owned by another user", async () => {
+		const todos = createTestTodoRepository();
+		const owner = createTester("user_owner", todos);
+		const intruder = createTester("user_intruder", todos);
+
+		const ownerCtx = await owner.ctx();
+		const created = await owner.run(
+			createTodoUseCase,
+			{ title: "Owned" },
+			{ ctx: ownerCtx },
+		);
+
+		const intruderCtx = await intruder.ctx();
+		await expect(
+			intruder.run(
+				updateTodoUseCase,
+				{ id: created.id, completed: true },
+				{ ctx: intruderCtx },
+			),
+		).rejects.toThrow("Only the owner can update this todo.");
+	});
+});
+`,
+    routesTest: `import { describe, expect, it } from "bun:test";
+import { createStaticAuth } from "@beignet/core/ports";
+import { createIdempotencyHooks, defineRoutes } from "@beignet/core/server";
+import { createTestPorts } from "@beignet/core/testing";
+import { createInMemoryDevtools } from "@beignet/devtools";
+import { createTestApp, createTestRequester } from "@beignet/web/testing";
+import type { AppContext } from "@/app-context";
+import type { TodoRepository } from "@/features/todos/ports";
+import { appPorts } from "@/infra/app-ports";
+import type { AppPorts, AppTransactionPorts } from "@/ports";
+import type { AuthRequest, AuthSessionMetadata, AuthUser } from "@/ports/auth";
+import { type AppServiceContextInput, appContext } from "@/server/context";
+import { createTodo, deleteTodo, listTodos, updateTodo } from "../contracts";
+import { todoRoutes } from "../routes";
+import { createTestTodoRepository } from "./helpers";
+
+function createSignedInAuth(userId: string): AppPorts["auth"] {
+	return createStaticAuth<AuthUser, AuthSessionMetadata, AuthRequest>({
+		user: { id: userId, email: \`\${userId}@example.com\`, name: "Test User" },
+		session: { id: \`session_\${userId}\` },
+	});
+}
+
+function createSignedOutAuth(): AppPorts["auth"] {
+	return createStaticAuth<AuthUser, AuthSessionMetadata, AuthRequest>(null);
+}
+
+async function createTodosTestApp(
+	options: { auth?: AppPorts["auth"]; todos?: TodoRepository } = {},
+) {
+	const todos = options.todos ?? createTestTodoRepository();
+	const fixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
+		base: appPorts,
+		overrides: {
+			gate: appPorts.gate,
+			todos,
+			devtools: createInMemoryDevtools(),
+			auth: options.auth ?? createSignedOutAuth(),
+		},
+		transaction: {
+			ports: (ports) => ({
+				...ports,
+				todos,
+			}),
+		},
+	});
+
+	return createTestApp<AppContext, AppContext["ports"], AppServiceContextInput>(
+		{
+			ports: fixture.ports,
+			context: appContext,
+			hooks: [createIdempotencyHooks<AppContext>()],
+			routes: defineRoutes<AppContext>([todoRoutes]),
+		},
+	);
+}
+
+describe("todoRoutes", () => {
+	it("requires a signed-in user", async () => {
+		const app = await createTodosTestApp();
+		const requester = createTestRequester(app, {});
+
+		const result = await requester.safeRequest(listTodos);
+
+		await app.stop();
+
+		expect(result.ok).toBe(false);
+		if (result.ok) throw new Error("Expected an error result.");
+		expect(result.status).toBe(401);
+		expect(result.error.code).toBe("UNAUTHORIZED");
+	});
+
+	it("creates, updates, lists, and deletes the user's todos", async () => {
+		const app = await createTodosTestApp({
+			auth: createSignedInAuth("user_test"),
+		});
+		const requester = createTestRequester(app, {});
+
+		const created = await requester.request(createTodo, {
+			body: { title: "Ship the starter" },
+			idempotencyKey: "todo-create-1",
+		});
+		// Replaying the same idempotency key returns the stored result instead
+		// of creating a second todo.
+		const replayed = await requester.request(createTodo, {
+			body: { title: "Ship the starter" },
+			idempotencyKey: "todo-create-1",
+		});
+		const updated = await requester.request(updateTodo, {
+			path: { id: created.id },
+			body: { completed: true },
+		});
+		const listed = await requester.request(listTodos);
+
+		expect(replayed.id).toBe(created.id);
+		expect(updated.completed).toBe(true);
+		expect(listed.page.total).toBe(1);
+		expect(listed.items).toEqual([updated]);
+
+		await requester.request(deleteTodo, { path: { id: created.id } });
+		const afterDelete = await requester.request(listTodos);
+
+		await app.stop();
+
+		expect(afterDelete.page.total).toBe(0);
+	});
+
+	it("hides other users' todos from the list", async () => {
+		const todos = createTestTodoRepository();
+		await todos.create({ userId: "user_other", title: "Not yours" });
+		const app = await createTodosTestApp({
+			auth: createSignedInAuth("user_owner"),
+			todos,
+		});
+		const requester = createTestRequester(app, {});
+
+		await requester.request(createTodo, { body: { title: "Owned" } });
+
+		const listed = await requester.request(listTodos);
+		await app.stop();
+
+		expect(listed.page.total).toBe(1);
+		expect(listed.items[0]?.userId).toBe("user_owner");
+	});
+});
+`,
+};
+export { files as todosFiles };
+//# sourceMappingURL=todos.js.map

package/dist/templates/todos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"todos.js","sourceRoot":"","sources":["../../src/templates/todos.ts"],"names":[],"mappings":"AAAA,MAAM,KAAK,GAAG;IACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDV;IACC,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DZ;IACC,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBR;IACC,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCT;IACC,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBT;IACC,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;CAmBnB;IACC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;CAiBpB;IACC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBpB;IACC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBpB;IACC,aAAa,EAAE;;;;;;;;;;;;;;;;CAgBhB;IACC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDd;IACC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHd;IACC,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Hb;CACA,CAAC;AAEF,OAAO,EAAE,KAAK,IAAI,UAAU,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beignet/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "description": "CLI for creating and maintaining Beignet apps.",
   "main": "./dist/lib.js",
@@ -66,7 +66,7 @@
     "typescript": "^5.3.0"
   },
   "dependencies": {
-    "@beignet/core": "^0.0.4",
+    "@beignet/core": "^0.0.6",
     "@clack/prompts": "^1.5.1",
     "@stricli/core": "^1.2.7",
     "jiti": "^2.7.0"