@tatara/cli 0.0.0-stage → 0.1.1

package/templates/features/storage/files/src/core/storage/local.ts

@@ -0,0 +1,34 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve, sep } from "node:path";
+import { env } from "#core/config/env";
+import { assertKey, type Storage } from "#core/storage/storage";
+
+/** Files on disk; for development and tests. */
+export function localStorage(root = env.STORAGE_LOCAL_DIR): Storage {
+	const base = resolve(root);
+	const path = (key: string) => {
+		const full = resolve(base, assertKey(key));
+		if (!full.startsWith(base + sep)) throw new Error(`Invalid storage key "${key}"`);
+		return full;
+	};
+	return {
+		async put(key, body) {
+			await mkdir(dirname(path(key)), { recursive: true });
+			await writeFile(path(key), body);
+		},
+		async get(key) {
+			try {
+				return new Uint8Array(await readFile(path(key)));
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		async delete(key) {
+			await rm(path(key), { force: true });
+		},
+		async url(key) {
+			return `file://${path(key)}`;
+		},
+	};
+}

package/templates/features/storage/files/src/core/storage/s3.ts

@@ -0,0 +1,66 @@
+import {
+	CreateBucketCommand,
+	DeleteObjectCommand,
+	GetObjectCommand,
+	HeadBucketCommand,
+	NoSuchKey,
+	PutObjectCommand,
+	S3Client,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { env } from "#core/config/env";
+import { assertKey, type Storage } from "#core/storage/storage";
+
+export const s3 = new S3Client({
+	region: env.S3_REGION,
+	...(env.S3_ENDPOINT ? { endpoint: env.S3_ENDPOINT } : {}),
+	forcePathStyle: env.S3_FORCE_PATH_STYLE,
+	...(env.S3_ACCESS_KEY_ID && env.S3_SECRET_ACCESS_KEY
+		? { credentials: { accessKeyId: env.S3_ACCESS_KEY_ID, secretAccessKey: env.S3_SECRET_ACCESS_KEY } }
+		: {}),
+});
+
+/** Any S3-compatible store (AWS S3, R2, RustFS locally). */
+export function s3Storage(bucket = env.S3_BUCKET): Storage {
+	let bucketReady: Promise<boolean> | undefined;
+	return {
+		async put(key, body, contentType) {
+			// local development: create the bucket on first write
+			if (env.NODE_ENV === "development") {
+				bucketReady ??= ensureBucket(bucket);
+				await bucketReady;
+			}
+			await s3.send(
+				new PutObjectCommand({ Bucket: bucket, Key: assertKey(key), Body: body, ContentType: contentType }),
+			);
+		},
+		async get(key) {
+			try {
+				const res = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: assertKey(key) }));
+				return res.Body ? await res.Body.transformToByteArray() : null;
+			} catch (error) {
+				if (error instanceof NoSuchKey) return null;
+				throw error;
+			}
+		},
+		async delete(key) {
+			await s3.send(new DeleteObjectCommand({ Bucket: bucket, Key: assertKey(key) }));
+		},
+		async url(key, expiresInSeconds = 900) {
+			return getSignedUrl(s3, new GetObjectCommand({ Bucket: bucket, Key: assertKey(key) }), {
+				expiresIn: expiresInSeconds,
+			});
+		},
+	};
+}
+
+/** Creates the bucket when it does not exist (local development). */
+export async function ensureBucket(bucket = env.S3_BUCKET): Promise<boolean> {
+	try {
+		await s3.send(new HeadBucketCommand({ Bucket: bucket }));
+		return false;
+	} catch {
+		await s3.send(new CreateBucketCommand({ Bucket: bucket }));
+		return true;
+	}
+}

package/templates/features/storage/files/src/core/storage/storage.ts

@@ -0,0 +1,21 @@
+/** Object storage used by modules; pick the driver with STORAGE_DRIVER. */
+export interface Storage {
+	put(key: string, body: Uint8Array | string, contentType?: string): Promise<void>;
+	get(key: string): Promise<Uint8Array | null>;
+	delete(key: string): Promise<void>;
+	/** a URL clients can fetch the object from (signed for S3) */
+	url(key: string, expiresInSeconds?: number): Promise<string>;
+}
+
+/** Keys are relative, forward-slash paths without "..", backslashes, NUL bytes or drive prefixes. */
+export function assertKey(key: string): string {
+	const invalid =
+		!key ||
+		key.startsWith("/") ||
+		key.includes("\\") ||
+		key.includes("\0") ||
+		/^[A-Za-z]:/.test(key) ||
+		key.split("/").some((segment) => segment === ".." || segment === ".");
+	if (invalid) throw new Error(`Invalid storage key "${key}"`);
+	return key;
+}

package/templates/features/storage/files/src/core/storage/tests/storage.test.ts

@@ -0,0 +1,22 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { localStorage } from "#core/storage/local";
+
+describe("local storage", () => {
+	it("round-trips an object", async () => {
+		const store = localStorage(await mkdtemp(join(tmpdir(), "storage-")));
+		await store.put("a/b.txt", "hello");
+		expect(new TextDecoder().decode((await store.get("a/b.txt")) ?? new Uint8Array())).toBe("hello");
+		await store.delete("a/b.txt");
+		expect(await store.get("a/b.txt")).toBeNull();
+	});
+
+	it("rejects keys that escape the root", async () => {
+		const store = localStorage(await mkdtemp(join(tmpdir(), "storage-")));
+		for (const key of ["../x", "a/../../x", "a\\..\\x", "/etc/passwd", "C:/x", "a/\0b"]) {
+			await expect(store.put(key, "no")).rejects.toThrow(/Invalid storage key/);
+		}
+	});
+});

package/templates/generators/command/files/src/modules/__moduleKebab__/commands/__nameKebab__.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { defineCommand, flag } from "#core/commands/define";
+
+export default defineCommand({
+	name: "__moduleKebab__:__nameKebab__",
+	description: "__nameTitle__",
+	args: z.object({ dryRun: flag() }),
+	async run({ dryRun }, { logger }) {
+		logger.info({ dryRun }, "__moduleKebab__:__nameKebab__ ran");
+	},
+});

package/templates/generators/consumer/files/src/modules/__moduleKebab__/consumers/__nameKebab__.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { defineConsumer } from "#core/jobs/define";
+
+export const __nameCamel__Payload = z.object({ id: z.string().min(1) });
+
+export default defineConsumer({
+	topic: "__moduleKebab__.__nameKebab__",
+	description: "__nameTitle__",
+	schema: __nameCamel__Payload,
+	async handle({ id }, { logger }) {
+		// must be idempotent: a job can run more than once
+		logger.info({ id }, "__moduleKebab__.__nameKebab__ handled");
+	},
+});

package/templates/generators/consumer/files/src/modules/__moduleKebab__/tests/__nameKebab__.consumer.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { processJob } from "#core/jobs/process";
+import { logger } from "#core/logging/logger";
+import { consumers } from "#generated/consumers";
+
+describe("__moduleKebab__.__nameKebab__", () => {
+	it("handles a valid payload", async () => {
+		await expect(
+			processJob(consumers, "__moduleKebab__.__nameKebab__", { id: "1" }, { logger, jobId: "t", attempt: 1 }),
+		).resolves.toBeUndefined();
+	});
+});

package/templates/generators/module/files/src/modules/__moduleKebab__/routes/__moduleKebab__.routes.ts

@@ -0,0 +1,20 @@
+import { createRoute } from "@hono/zod-openapi";
+import { jsonContent, success, successSchema } from "#core/http/response";
+import { createRouter, defineRoutes } from "#core/http/routes";
+import { __moduleCamel__Status } from "#modules/__moduleKebab__/services/__moduleKebab__.service";
+import { __moduleCamel__StatusSchema } from "#modules/__moduleKebab__/validators/__moduleKebab__.validators";
+
+const router = createRouter();
+
+router.openapi(
+	createRoute({
+		method: "get",
+		path: "/status",
+		tags: ["__modulePascal__"],
+		summary: "__moduleTitle__ module status",
+		responses: { 200: jsonContent(successSchema(__moduleCamel__StatusSchema), "Status") },
+	}),
+	(c) => c.json(success(__moduleCamel__Status()), 200),
+);
+
+export default defineRoutes({ app: "api", basePath: "/__moduleKebab__", router });

package/templates/generators/module/files/src/modules/__moduleKebab__/services/__moduleKebab__.service.ts

@@ -0,0 +1,4 @@
+/** Business logic for the __moduleKebab__ module: plain functions, no HTTP. */
+export function __moduleCamel__Status(): { module: string; status: "ok" } {
+	return { module: "__moduleKebab__", status: "ok" };
+}

package/templates/generators/module/files/src/modules/__moduleKebab__/tests/__moduleKebab__.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { api } from "#tests/helpers/api";
+
+describe("__moduleKebab__", () => {
+	it("reports status", async () => {
+		const res = await api.get("/api/__moduleKebab__/status");
+		expect(res.status).toBe(200);
+		expect(res.body).toEqual({ success: true, data: { module: "__moduleKebab__", status: "ok" } });
+	});
+});

package/templates/generators/module/files/src/modules/__moduleKebab__/validators/__moduleKebab__.validators.ts

@@ -0,0 +1,5 @@
+import { z } from "@hono/zod-openapi";
+
+export const __moduleCamel__StatusSchema = z
+	.object({ module: z.string(), status: z.literal("ok") })
+	.openapi("__modulePascal__Status");

package/templates/generators/permission/files/src/modules/__moduleKebab__/permissions/__nameKebab__.permissions.ts

@@ -0,0 +1,18 @@
+import { definePermissions } from "#core/authz/catalog";
+
+export default definePermissions({
+	resources: {
+		"__nameKebab__": {
+			// scoped actions are checked at own | team | org; use resolveScope() in the service
+			read: { scoped: true },
+			manage: { scoped: false },
+		},
+	},
+	roleGrants: {
+		admin: [
+			["__nameKebab__", "read", "org"],
+			["__nameKebab__", "manage"],
+		],
+		member: [["__nameKebab__", "read", "own"]],
+	},
+});

package/templates/generators/resource/files/src/modules/__moduleKebab__/routes/__nameKebab__.routes.ts

@@ -0,0 +1,127 @@
+import { createRoute } from "@hono/zod-openapi";
+import {
+	errorResponses,
+	jsonBody,
+	jsonContent,
+	paginated,
+	paginatedSchema,
+	paginationQuerySchema,
+	success,
+	successSchema,
+} from "#core/http/response";
+import { createRouter, defineRoutes } from "#core/http/routes";
+// tatara:slot imports
+import {
+	create__namePascal__,
+	get__namePascal__,
+	list__namePluralPascal__,
+	remove__namePascal__,
+	update__namePascal__,
+} from "#modules/__moduleKebab__/services/__nameKebab__.service";
+import {
+	__nameCamel__ParamsSchema,
+	__nameCamel__Schema,
+	create__namePascal__Schema,
+	update__namePascal__Schema,
+} from "#modules/__moduleKebab__/validators/__nameKebab__.validators";
+
+const router = createRouter();
+const tags = ["__namePluralPascal__"];
+
+router.openapi(
+	createRoute({
+		method: "get",
+		path: "/",
+		tags,
+		summary: "List __namePluralKebab__",
+		// tatara:slot guard-list
+		request: { query: paginationQuerySchema },
+		responses: {
+			200: jsonContent(paginatedSchema(__nameCamel__Schema), "A page of __namePluralKebab__"),
+			...errorResponses(400),
+			// tatara:slot auth-errors
+		},
+	}),
+	async (c) => {
+		const query = c.req.valid("query");
+		const { items, total } = await list__namePluralPascal__(query);
+		return c.json(paginated(items, query.page, query.pageSize, total), 200);
+	},
+);
+
+router.openapi(
+	createRoute({
+		method: "get",
+		path: "/{id}",
+		tags,
+		summary: "Get a __nameKebab__",
+		// tatara:slot guard-read
+		request: { params: __nameCamel__ParamsSchema },
+		responses: {
+			200: jsonContent(successSchema(__nameCamel__Schema), "The __nameKebab__"),
+			...errorResponses(400, 404),
+			// tatara:slot auth-errors
+		},
+	}),
+	async (c) => c.json(success(await get__namePascal__(c.req.valid("param").id)), 200),
+);
+
+router.openapi(
+	createRoute({
+		method: "post",
+		path: "/",
+		tags,
+		summary: "Create a __nameKebab__",
+		// tatara:slot guard-create
+		request: { body: jsonBody(create__namePascal__Schema, "The new __nameKebab__") },
+		responses: {
+			201: jsonContent(successSchema(__nameCamel__Schema), "Created"),
+			...errorResponses(400),
+			// tatara:slot auth-errors
+		},
+	}),
+	async (c) => c.json(success(await create__namePascal__(c.req.valid("json"))), 201),
+);
+
+router.openapi(
+	createRoute({
+		method: "patch",
+		path: "/{id}",
+		tags,
+		summary: "Update a __nameKebab__",
+		// tatara:slot guard-update
+		request: {
+			params: __nameCamel__ParamsSchema,
+			body: jsonBody(update__namePascal__Schema, "Fields to change"),
+		},
+		responses: {
+			200: jsonContent(successSchema(__nameCamel__Schema), "Updated"),
+			...errorResponses(400, 404),
+			// tatara:slot auth-errors
+		},
+	}),
+	async (c) =>
+		c.json(success(await update__namePascal__(c.req.valid("param").id, c.req.valid("json"))), 200),
+);
+
+router.openapi(
+	createRoute({
+		method: "delete",
+		path: "/{id}",
+		tags,
+		summary: "Delete a __nameKebab__",
+		// tatara:slot guard-delete
+		request: { params: __nameCamel__ParamsSchema },
+		responses: {
+			204: { description: "Deleted" },
+			...errorResponses(400, 404),
+			// tatara:slot auth-errors
+		},
+	}),
+	async (c) => {
+		await remove__namePascal__(c.req.valid("param").id);
+		return c.body(null, 204);
+	},
+);
+
+export default defineRoutes({ app: "api", basePath: "/__namePluralKebab__", router });

package/templates/generators/resource/files/src/modules/__moduleKebab__/tests/__nameKebab__.routes.test.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { api } from "#tests/helpers/api";
+import { resetDatabase } from "#tests/helpers/db";
+// tatara:slot test-imports
+
+const path = "/api/__namePluralKebab__";
+const headers: Record<string, string> = {};
+
+interface __namePascal__Body {
+	data: { id: string; name: string; description: string | null };
+}
+
+beforeEach(async () => {
+	await resetDatabase();
+	// tatara:slot test-auth
+});
+
+describe("__namePluralKebab__", () => {
+	it("creates, reads, updates, lists and deletes", async () => {
+		const created = await api.post<__namePascal__Body>(path, { name: "First" }, { headers });
+		expect(created.status).toBe(201);
+		const { id } = created.body.data;
+		expect(created.body.data).toMatchObject({ name: "First", description: null });
+
+		const read = await api.get<__namePascal__Body>(`${path}/${id}`, { headers });
+		expect(read.status).toBe(200);
+		expect(read.body.data.id).toBe(id);
+
+		const updated = await api.patch<__namePascal__Body>(
+			`${path}/${id}`,
+			{ description: "Changed" },
+			{ headers },
+		);
+		expect(updated.status).toBe(200);
+		expect(updated.body.data).toMatchObject({ name: "First", description: "Changed" });
+
+		await api.post(path, { name: "Second" }, { headers });
+		const list = await api.get<{ data: { name: string }[]; meta: { total: number } }>(
+			`${path}?pageSize=10`,
+			{ headers },
+		);
+		expect(list.status).toBe(200);
+		expect(list.body.meta.total).toBe(2);
+		expect(list.body.data.map((item) => item.name)).toEqual(["Second", "First"]);
+
+		const removed = await api.delete(`${path}/${id}`, { headers });
+		expect(removed.status).toBe(204);
+		const gone = await api.get(`${path}/${id}`, { headers });
+		expect(gone.status).toBe(404);
+	});
+
+	it("rejects invalid input", async () => {
+		const res = await api.post(path, { name: "" }, { headers });
+		expect(res.status).toBe(400);
+		expect(res.body).toMatchObject({ success: false, code: "VALIDATION_ERROR" });
+	});
+
+	// tatara:slot test-cases
+});

package/templates/generators/resource/files/src/modules/__moduleKebab__/validators/__nameKebab__.validators.ts

@@ -0,0 +1,30 @@
+import { z } from "@hono/zod-openapi";
+
+export const __nameCamel__Schema = z
+	.object({
+		id: z.string().openapi({ example: "01920000-0000-7000-8000-000000000000" }),
+		name: z.string().openapi({ example: "My __nameTitle__" }),
+		description: z.string().nullable(),
+		createdAt: z.string().openapi({ format: "date-time" }),
+		updatedAt: z.string().openapi({ format: "date-time" }),
+	})
+	.openapi("__namePascal__");
+
+export const create__namePascal__Schema = z
+	.object({
+		name: z.string().trim().min(1).max(200),
+		description: z.string().max(5000).nullable().optional(),
+	})
+	.openapi("Create__namePascal__");
+
+export const update__namePascal__Schema = create__namePascal__Schema
+	.partial()
+	.openapi("Update__namePascal__");
+
+export const __nameCamel__ParamsSchema = z.object({
+	id: z.string().min(1).openapi({ param: { name: "id", in: "path" } }),
+});
+
+export type __namePascal__ = z.infer<typeof __nameCamel__Schema>;
+export type Create__namePascal__Input = z.infer<typeof create__namePascal__Schema>;
+export type Update__namePascal__Input = z.infer<typeof update__namePascal__Schema>;

package/templates/generators/resource/files+authz/src/modules/__moduleKebab__/permissions/__nameKebab__.permissions.ts

@@ -0,0 +1,21 @@
+import { definePermissions } from "#core/authz/catalog";
+
+export default definePermissions({
+	resources: {
+		"__nameKebab__": {
+			read: { scoped: false },
+			create: { scoped: false },
+			update: { scoped: false },
+			delete: { scoped: false },
+		},
+	},
+	roleGrants: {
+		admin: [
+			["__nameKebab__", "read"],
+			["__nameKebab__", "create"],
+			["__nameKebab__", "update"],
+			["__nameKebab__", "delete"],
+		],
+		member: [["__nameKebab__", "read"]],
+	},
+});

package/templates/generators/resource/files+drizzle/src/modules/__moduleKebab__/services/__nameKebab__.service.ts

@@ -0,0 +1,78 @@
+import { count, desc, eq } from "drizzle-orm";
+import { db, type Executor } from "#core/db/client";
+import { newId } from "#core/db/id";
+import { NotFoundError } from "#core/http/errors";
+import type { PaginationQuery } from "#core/http/response";
+import { __namePluralCamel__ } from "#modules/__moduleKebab__/db/__nameKebab__.schema";
+import type {
+	Create__namePascal__Input,
+	__namePascal__,
+	Update__namePascal__Input,
+} from "#modules/__moduleKebab__/validators/__nameKebab__.validators";
+
+type Row = typeof __namePluralCamel__.$inferSelect;
+
+function to__namePascal__(row: Row): __namePascal__ {
+	return {
+		id: row.id,
+		name: row.name,
+		description: row.description,
+		createdAt: row.createdAt.toISOString(),
+		updatedAt: row.updatedAt.toISOString(),
+	};
+}
+
+export async function list__namePluralPascal__(
+	{ page, pageSize }: PaginationQuery,
+	executor: Executor = db,
+) {
+	const [rows, totals] = await Promise.all([
+		executor
+			.select()
+			.from(__namePluralCamel__)
+			.orderBy(desc(__namePluralCamel__.id))
+			.limit(pageSize)
+			.offset((page - 1) * pageSize),
+		executor.select({ total: count() }).from(__namePluralCamel__),
+	]);
+	return { items: rows.map(to__namePascal__), total: totals[0]?.total ?? 0 };
+}
+
+export async function get__namePascal__(id: string, executor: Executor = db): Promise<__namePascal__> {
+	const [row] = await executor
+		.select()
+		.from(__namePluralCamel__)
+		.where(eq(__namePluralCamel__.id, id))
+		.limit(1);
+	if (!row) throw new NotFoundError("__nameTitle__");
+	return to__namePascal__(row);
+}
+
+export async function create__namePascal__(
+	input: Create__namePascal__Input,
+	executor: Executor = db,
+): Promise<__namePascal__> {
+	const id = newId();
+	await executor
+		.insert(__namePluralCamel__)
+		.values({ id, name: input.name, description: input.description ?? null });
+	return get__namePascal__(id, executor);
+}
+
+export async function update__namePascal__(
+	id: string,
+	input: Update__namePascal__Input,
+	executor: Executor = db,
+): Promise<__namePascal__> {
+	await get__namePascal__(id, executor);
+	await executor
+		.update(__namePluralCamel__)
+		.set({ ...input, updatedAt: new Date() })
+		.where(eq(__namePluralCamel__.id, id));
+	return get__namePascal__(id, executor);
+}
+
+export async function remove__namePascal__(id: string, executor: Executor = db): Promise<void> {
+	await get__namePascal__(id, executor);
+	await executor.delete(__namePluralCamel__).where(eq(__namePluralCamel__.id, id));
+}

package/templates/generators/resource/files+drizzle+mysql/src/modules/__moduleKebab__/db/__nameKebab__.schema.ts

@@ -0,0 +1,9 @@
+import { mysqlTable, text, timestamp, varchar } from "drizzle-orm/mysql-core";
+
+export const __namePluralCamel__ = mysqlTable("__namePluralSnake__", {
+	id: varchar({ length: 36 }).primaryKey(),
+	name: varchar({ length: 200 }).notNull(),
+	description: text(),
+	createdAt: timestamp({ fsp: 3, mode: "date" }).notNull().defaultNow(),
+	updatedAt: timestamp({ fsp: 3, mode: "date" }).notNull().defaultNow(),
+});

package/templates/generators/resource/files+drizzle+postgres/src/modules/__moduleKebab__/db/__nameKebab__.schema.ts

@@ -0,0 +1,9 @@
+import { pgTable, text, timestamp, uuid, varchar } from "drizzle-orm/pg-core";
+
+export const __namePluralCamel__ = pgTable("__namePluralSnake__", {
+	id: uuid().primaryKey(),
+	name: varchar({ length: 200 }).notNull(),
+	description: text(),
+	createdAt: timestamp({ withTimezone: true, mode: "date" }).notNull().defaultNow(),
+	updatedAt: timestamp({ withTimezone: true, mode: "date" }).notNull().defaultNow(),
+});

package/templates/generators/resource/files+prisma/prisma/models/__nameKebab__.prisma

@@ -0,0 +1,9 @@
+model __namePascal__ {
+  id          String   @id @db.VarChar(36)
+  name        String   @db.VarChar(200)
+  description String?  @db.Text
+  createdAt   DateTime @default(now()) @map("created_at")
+  updatedAt   DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@map("__namePluralSnake__")
+}

package/templates/generators/resource/files+prisma/src/modules/__moduleKebab__/services/__nameKebab__.service.ts

@@ -0,0 +1,73 @@
+import { db, type Executor } from "#core/db/client";
+import { newId } from "#core/db/id";
+import { NotFoundError } from "#core/http/errors";
+import type { PaginationQuery } from "#core/http/response";
+import type {
+	Create__namePascal__Input,
+	__namePascal__,
+	Update__namePascal__Input,
+} from "#modules/__moduleKebab__/validators/__nameKebab__.validators";
+
+interface Row {
+	id: string;
+	name: string;
+	description: string | null;
+	createdAt: Date;
+	updatedAt: Date;
+}
+
+function to__namePascal__(row: Row): __namePascal__ {
+	return {
+		id: row.id,
+		name: row.name,
+		description: row.description,
+		createdAt: row.createdAt.toISOString(),
+		updatedAt: row.updatedAt.toISOString(),
+	};
+}
+
+export async function list__namePluralPascal__(
+	{ page, pageSize }: PaginationQuery,
+	executor: Executor = db,
+) {
+	const [rows, total] = await Promise.all([
+		executor.__nameCamel__.findMany({
+			orderBy: { id: "desc" },
+			skip: (page - 1) * pageSize,
+			take: pageSize,
+		}),
+		executor.__nameCamel__.count(),
+	]);
+	return { items: rows.map(to__namePascal__), total };
+}
+
+export async function get__namePascal__(id: string, executor: Executor = db): Promise<__namePascal__> {
+	const row = await executor.__nameCamel__.findUnique({ where: { id } });
+	if (!row) throw new NotFoundError("__nameTitle__");
+	return to__namePascal__(row);
+}
+
+export async function create__namePascal__(
+	input: Create__namePascal__Input,
+	executor: Executor = db,
+): Promise<__namePascal__> {
+	const row = await executor.__nameCamel__.create({
+		data: { id: newId(), name: input.name, description: input.description ?? null },
+	});
+	return to__namePascal__(row);
+}
+
+export async function update__namePascal__(
+	id: string,
+	input: Update__namePascal__Input,
+	executor: Executor = db,
+): Promise<__namePascal__> {
+	await get__namePascal__(id, executor);
+	const row = await executor.__nameCamel__.update({ where: { id }, data: input });
+	return to__namePascal__(row);
+}
+
+export async function remove__namePascal__(id: string, executor: Executor = db): Promise<void> {
+	await get__namePascal__(id, executor);
+	await executor.__nameCamel__.delete({ where: { id } });
+}