@kematjaya/crud-ui-generator 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @kematjaya/crud-ui-generator
+
+Next.js CRUD frontend generator that reads the `crud-specs/{Entity}.json` sidecar written by
+[kematjaya/crud-maker-bundle](https://github.com/kematjaya0/crud-maker-bundle)'s
+`make:kmj-api-crud`, and generates pages, components, and BFF routes matching the shape of a
+hand-written CRUD feature (list/create/edit pages, table with search/pagination/bulk-delete/CSV
+export, form, BFF proxy routes).
+
+This is a dev-time code generator (like Plop/Hygen), not a runtime component library. It targets
+projects that already follow this monorepo's Next.js conventions:
+
+- `@kematjaya/bootstrap-ui-kit` for `ListPageCard`/`TextField`/`Button`/etc.
+- `@kematjaya/access-control-ui` for `usePermissions()`
+- `src/lib/http.ts`, `src/lib/bff.ts` (BFF proxy helpers — `authedBackend`, `validateOrigin`, `parseJson`, `jsonProblem`)
+- `src/lib/permissions.ts` exporting `requirePermission()`
+- `src/types/api.ts` + `src/types/api.generated.ts` (OpenAPI types via `openapi-typescript`)
+
+It is not a general-purpose Next.js scaffolder — running it against a project that doesn't already
+have those pieces will produce files that don't compile until you add them.
+
+## Usage
+
+```
+npx @kematjaya/crud-ui-generator <spec-path> [--src <dir>]
+```
+
+- `<spec-path>` — path to the `crud-specs/{Entity}.json` file written by `make:kmj-api-crud`.
+- `--src <dir>` — the frontend project's `src/` directory to generate into (default: `src`).
+
+Example, run from the frontend project root, with the backend as a sibling directory:
+
+```
+npx @kematjaya/crud-ui-generator ../backend/crud-specs/Note.json --src src
+```
+
+## What it generates
+
+Per entity (skipped if the file already exists — safe to re-run):
+
+- `app/dashboard/{entities}/page.tsx`, `new/page.tsx`, `[id]/edit/page.tsx`
+- `components/{entities}/{Entity}Table.tsx`, `{Entity}Form.tsx`, `use{Entities}Export.ts`
+- `lib/{entities}-query.ts`, `lib/{entities}-csv.ts`
+- `app/api/{entities}/route.ts`, `[id]/route.ts`, `export/route.ts` (BFF proxy)
+
+Shared, entity-agnostic UI primitives (written once, reused by every entity):
+
+- `components/crud/DeleteConfirmModal.tsx`, `BulkActionsBar.tsx`, `PaginationBar.tsx`,
+  `SearchPanel.tsx`, `ExportAllButton.tsx`
+
+Appended to (multi-entity, idempotent — each entity gets one marker-guarded block):
+
+- `lib/api-shapes.ts` — `is{Entity}`/`is{Entity}Collection` type guards
+- `lib/schemas.ts` — a Zod schema per entity
+- `types/api.ts` — types derived from the OpenAPI-generated `paths`/`components`
+
+## Assumptions / caveats
+
+- **Ids are UUID strings.** `validId()` in the generated `[id]/route.ts` checks a 36-char
+  hex-with-dashes pattern. Adjust by hand if an entity uses a different id type.
+- **The list search box only searches one field.** If more than one field is marked
+  `searchable` in the spec, the list view (backed by ApiPlatform's `SearchFilter`, one query
+  param per property) only wires up the first one. The export endpoint ORs across all of them.
+- **The table/CSV export skip `textarea` fields** (long text), mirroring the hand-written Notes
+  feature (shows `title`, not `body`). Everything else (`text`/`number`/`boolean`) becomes a
+  column.
+- **Getters are assumed on the entity/generated types** in the conventional `get{Field}()` /
+  camelCase-property shape used throughout this boilerplate.
+- **`npm run api:types` must be run first** (after adding the backend's `#[ApiResource]`/
+  `#[ApiFilter]` attributes — see `make:kmj-api-crud`'s printed next-steps) so
+  `src/types/api.ts`'s `paths['/api/{entities}']` / `components['schemas'][...]` lookups resolve.
+  If the entity's `#[ApiResource]` uses a custom `uriTemplate` that doesn't match
+  `permissionPrefix`, fix those lookups by hand.
+- Generated files aren't run through Prettier — run `npm run format` afterwards.
+
+## Development
+
+```
+npm install
+npm run build   # tsc -> dist/
+```

package/dist/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { join, resolve } from 'node:path';
+import { loadSpec } from './spec.js';
+import { namesFromSpec, searchField, searchableFields } from './naming.js';
+import { appendBlock, appendBlockWithImport, newLog, writeIfMissing, writeNewFile } from './write.js';
+import * as shared from './templates/sharedComponents.js';
+import { editPage, listPage, newPage } from './templates/pages.js';
+import { table } from './templates/table.js';
+import { form } from './templates/form.js';
+import { useExportHook } from './templates/useExport.js';
+import { queryLib } from './templates/queryLib.js';
+import { csvLib } from './templates/csvLib.js';
+import { apiShapesBlock, apiShapesFileHeader, apiShapesImport, apiShapesMarker } from './templates/apiShapes.js';
+import { schemasBlock, schemasFileHeader, schemasMarker } from './templates/schemas.js';
+import { typesApiBlock, typesApiFileHeader, typesApiMarker } from './templates/typesApi.js';
+import { exportRoute, itemRoute, listRoute } from './templates/bffRoutes.js';
+function parseArgs(argv) {
+    const positional = [];
+    let srcDir = 'src';
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--src') {
+            const next = argv[++i];
+            if (!next)
+                throw new Error('--src requires a value');
+            srcDir = next;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            printUsage();
+            process.exit(0);
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    const specPath = positional[0];
+    if (!specPath) {
+        printUsage();
+        throw new Error('Missing required <spec-path> argument.');
+    }
+    return { specPath, srcDir };
+}
+function printUsage() {
+    console.log(`Usage: crud-ui-generate <spec-path> [--src <dir>]
+
+  <spec-path>   Path to the crud-specs/{Entity}.json sidecar written by
+                kematjaya/crud-maker-bundle's "make:kmj-api-crud".
+  --src <dir>   Frontend src/ directory to generate into (default: "src").
+
+Example:
+  npx @kematjaya/crud-ui-generator ../backend/crud-specs/Note.json --src src
+`);
+}
+function report(log) {
+    for (const path of log.created)
+        console.log(`  created   ${path}`);
+    for (const path of log.appended)
+        console.log(`  appended  ${path}`);
+    for (const path of log.skipped)
+        console.log(`  skip      ${path} (already exists)`);
+}
+function main() {
+    const { specPath, srcDir } = parseArgs(process.argv.slice(2));
+    const spec = loadSpec(resolve(specPath));
+    const names = namesFromSpec(spec);
+    const src = resolve(srcDir);
+    const log = newLog();
+    const cruddir = join(src, 'components', 'crud');
+    writeIfMissing(join(cruddir, 'DeleteConfirmModal.tsx'), shared.deleteConfirmModal, log);
+    writeIfMissing(join(cruddir, 'BulkActionsBar.tsx'), shared.bulkActionsBar, log);
+    writeIfMissing(join(cruddir, 'PaginationBar.tsx'), shared.paginationBar, log);
+    writeIfMissing(join(cruddir, 'ExportAllButton.tsx'), shared.exportAllButton, log);
+    if (null !== searchField(spec)) {
+        writeIfMissing(join(cruddir, 'SearchPanel.tsx'), shared.searchPanel, log);
+    }
+    const dashDir = join(src, 'app', 'dashboard', names.entitiesKebab);
+    writeNewFile(join(dashDir, 'page.tsx'), listPage(names), log);
+    writeNewFile(join(dashDir, 'new', 'page.tsx'), newPage(names), log);
+    writeNewFile(join(dashDir, '[id]', 'edit', 'page.tsx'), editPage(names), log);
+    const compDir = join(src, 'components', names.entitiesKebab);
+    writeNewFile(join(compDir, `${names.entityPascal}Table.tsx`), table(spec, names), log);
+    writeNewFile(join(compDir, `${names.entityPascal}Form.tsx`), form(spec, names), log);
+    writeNewFile(join(compDir, `use${names.entitiesPascal}Export.ts`), useExportHook(spec, names), log);
+    const libDir = join(src, 'lib');
+    writeNewFile(join(libDir, `${names.entitiesKebab}-query.ts`), queryLib(spec, names), log);
+    writeNewFile(join(libDir, `${names.entitiesKebab}-csv.ts`), csvLib(spec, names), log);
+    appendBlockWithImport(join(libDir, 'api-shapes.ts'), apiShapesFileHeader, apiShapesImport(names), apiShapesMarker(names.entityPascal), apiShapesBlock(spec, names), log);
+    appendBlock(join(libDir, 'schemas.ts'), schemasFileHeader, schemasMarker(names.entityCamel), schemasBlock(spec, names), log);
+    appendBlock(join(src, 'types', 'api.ts'), typesApiFileHeader, typesApiMarker(names.entityPascal), typesApiBlock(spec, names), log);
+    const apiDir = join(src, 'app', 'api', names.entitiesKebab);
+    writeNewFile(join(apiDir, 'route.ts'), listRoute(spec, names), log);
+    writeNewFile(join(apiDir, '[id]', 'route.ts'), itemRoute(spec, names), log);
+    writeNewFile(join(apiDir, 'export', 'route.ts'), exportRoute(spec, names), log);
+    report(log);
+    console.log('');
+    console.log(`Generated ${names.entityPascal} CRUD UI. Before it works end-to-end:`);
+    console.log(`  1. Run the backend maker's printed next-steps (ApiResource/ApiFilter attributes, permission keys, rate limiter config).`);
+    console.log(`  2. Run "npm run api:types" in the frontend project so src/types/api.ts's paths/components lookups resolve.`);
+    console.log(`  3. Confirm the OpenAPI collection path is "/api/${names.entitiesKebab}" — if the entity's #[ApiResource] uses a custom uriTemplate, fix the "paths[...]" lookups in the appended src/types/api.ts block by hand.`);
+    if (searchableFields(spec).length > 1) {
+        console.log(`  4. Note: multiple searchable fields were configured (${searchableFields(spec).join(', ')}); the list view's single search box only queries by "${searchField(spec)}" (ApiPlatform SearchFilter's per-property param convention doesn't support one box matching several properties). The export endpoint does OR across all of them.`);
+    }
+    console.log(`  Assumes UUID-shaped ids (matches this boilerplate's convention) — see validId() in the generated app/api/${names.entitiesKebab}/[id]/route.ts if this entity uses a different id type.`);
+    console.log(`  Run "npm run format" afterwards — generated files aren't pre-formatted to this project's Prettier config.`);
+}
+main();

package/dist/naming.js

@@ -0,0 +1,47 @@
+function kebabToPascal(kebab) {
+    return kebab
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+export function namesFromSpec(spec) {
+    const entityPascal = spec.entity;
+    const entityCamel = entityPascal.charAt(0).toLowerCase() + entityPascal.slice(1);
+    const entitiesKebab = spec.permissionPrefix;
+    const entitiesPascal = kebabToPascal(entitiesKebab);
+    const entitiesCamel = entitiesPascal.charAt(0).toLowerCase() + entitiesPascal.slice(1);
+    return { entityPascal, entityCamel, entitiesKebab, entitiesPascal, entitiesCamel };
+}
+/** The single field used for the search box / list-view SearchFilter query param, if any. */
+export function searchField(spec) {
+    return spec.fields.find((f) => f.searchable)?.name ?? null;
+}
+/** All searchable field names, used by the export endpoint's OR-search. */
+export function searchableFields(spec) {
+    return spec.fields.filter((f) => f.searchable).map((f) => f.name);
+}
+/** "createdAt" -> "Created At", "TestArticle" -> "Test Article". */
+export function humanize(identifier) {
+    const words = identifier
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[-_]/g, ' ')
+        .trim()
+        .split(/\s+/);
+    return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+/** "TestArticles" -> "test articles" — used for prose/aria copy. */
+export function lowerWords(identifier) {
+    return humanize(identifier).toLowerCase();
+}
+/**
+ * Fields shown as table columns / export CSV columns: everything except long-text (textarea)
+ * fields, mirroring how the hand-written Notes table shows `title` but not `body`.
+ */
+export function displayFields(spec) {
+    return spec.fields.filter((f) => f.type !== 'textarea');
+}
+/** Field used to label a single row in delete-confirmation copy / aria-labels. */
+export function labelField(spec) {
+    return displayFields(spec)[0]?.name ?? spec.fields[0]?.name ?? 'id';
+}

package/dist/spec.js

@@ -0,0 +1,47 @@
+import { readFileSync } from 'node:fs';
+function isFieldSpec(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const f = value;
+    return (typeof f.name === 'string' &&
+        ['text', 'textarea', 'number', 'boolean'].includes(f.type) &&
+        typeof f.required === 'boolean' &&
+        (f.maxLength === null || typeof f.maxLength === 'number') &&
+        typeof f.searchable === 'boolean');
+}
+export function loadSpec(specPath) {
+    let raw;
+    try {
+        raw = readFileSync(specPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Could not read spec file: ${specPath}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Spec file is not valid JSON: ${specPath}`);
+    }
+    if (typeof data !== 'object' || data === null) {
+        throw new Error(`Spec file must contain a JSON object: ${specPath}`);
+    }
+    const spec = data;
+    if (typeof spec.entity !== 'string' || spec.entity === '') {
+        throw new Error(`Spec file missing "entity": ${specPath}`);
+    }
+    if (typeof spec.permissionPrefix !== 'string' || spec.permissionPrefix === '') {
+        throw new Error(`Spec file missing "permissionPrefix": ${specPath}`);
+    }
+    if (!Array.isArray(spec.fields) || !spec.fields.every(isFieldSpec)) {
+        throw new Error(`Spec file "fields" is missing or malformed: ${specPath}`);
+    }
+    return {
+        entity: spec.entity,
+        permissionPrefix: spec.permissionPrefix,
+        ownerProperty: typeof spec.ownerProperty === 'string' ? spec.ownerProperty : null,
+        timestampField: typeof spec.timestampField === 'string' ? spec.timestampField : null,
+        fields: spec.fields,
+    };
+}

package/dist/templates/apiShapes.js

@@ -0,0 +1,45 @@
+function tsType(field) {
+    if (field.type === 'number')
+        return 'number';
+    if (field.type === 'boolean')
+        return 'boolean';
+    return 'string';
+}
+/** Fresh-file bootstrap, only used when src/lib/api-shapes.ts doesn't exist yet. */
+export const apiShapesFileHeader = `export function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+`;
+export function apiShapesMarker(entityPascal) {
+    return `export function is${entityPascal}(`;
+}
+export function apiShapesImport(names) {
+    return `import type { ${names.entityPascal}, ${names.entitiesPascal}Collection } from '@/types/api';\n`;
+}
+export function apiShapesBlock(spec, names) {
+    const { entityPascal, entitiesPascal } = names;
+    const checks = ['isRecord(value)', "typeof value.id === 'string'"];
+    for (const field of spec.fields) {
+        checks.push(`typeof value.${field.name} === '${tsType(field)}'`);
+    }
+    if (null !== spec.timestampField) {
+        checks.push(`typeof value.${spec.timestampField} === 'string'`);
+    }
+    const checksBlock = checks.map((c, i) => `        ${c}${i < checks.length - 1 ? ' &&' : ''}`).join('\n');
+    return `
+export function is${entityPascal}(value: unknown): value is ${entityPascal} {
+    return (
+${checksBlock}
+    );
+}
+
+export function is${entityPascal}Collection(value: unknown): value is ${entitiesPascal}Collection {
+    return (
+        isRecord(value) &&
+        typeof value.totalItems === 'number' &&
+        Array.isArray(value.member) &&
+        value.member.every(is${entityPascal})
+    );
+}
+`;
+}

package/dist/templates/bffRoutes.js

@@ -0,0 +1,175 @@
+import { displayFields, searchField } from '../naming.js';
+function tsType(field) {
+    if (field.type === 'number')
+        return 'number';
+    if (field.type === 'boolean')
+        return 'boolean';
+    return 'string';
+}
+export function listRoute(_spec, names) {
+    const { entityCamel, entitiesKebab } = names;
+    return `import type { NextRequest } from 'next/server';
+import { authedBackend } from '@/lib/bff';
+import { parseJson, validateOrigin } from '@/lib/http';
+import { build${names.entitiesPascal}ApiPath, parse${names.entitiesPascal}Query } from '@/lib/${entitiesKebab}-query';
+import { ${entityCamel}Schema } from '@/lib/schemas';
+
+export async function GET(request: NextRequest) {
+    return authedBackend(
+        build${names.entitiesPascal}ApiPath(parse${names.entitiesPascal}Query(request.nextUrl.searchParams))
+    );
+}
+
+export async function POST(request: NextRequest) {
+    const badOrigin = validateOrigin(request);
+    if (badOrigin) return badOrigin;
+    const parsed = await parseJson(request, ${entityCamel}Schema);
+    if ('error' in parsed) return parsed.error;
+    return authedBackend('/api/${entitiesKebab}', {
+        method: 'POST',
+        body: JSON.stringify(parsed.data)
+    });
+}
+
+export const dynamic = 'force-dynamic';
+export const revalidate = 0;
+`;
+}
+export function itemRoute(_spec, names) {
+    const { entityCamel, entitiesKebab } = names;
+    return `import type { NextRequest } from 'next/server';
+import { authedBackend } from '@/lib/bff';
+import { jsonProblem, parseJson, validateOrigin } from '@/lib/http';
+import { ${entityCamel}Schema } from '@/lib/schemas';
+
+type Params = { params: Promise<{ id: string }> };
+
+function validId(id: string) {
+    return /^[0-9a-fA-F-]{36}$/.test(id);
+}
+
+export async function GET(_request: NextRequest, context: Params) {
+    const { id } = await context.params;
+    if (!validId(id)) return jsonProblem(404, { title: 'Not Found' });
+    return authedBackend(\`/api/${entitiesKebab}/\${id}\`);
+}
+
+export async function PATCH(request: NextRequest, context: Params) {
+    const badOrigin = validateOrigin(request);
+    if (badOrigin) return badOrigin;
+    const { id } = await context.params;
+    if (!validId(id)) return jsonProblem(404, { title: 'Not Found' });
+    const parsed = await parseJson(request, ${entityCamel}Schema);
+    if ('error' in parsed) return parsed.error;
+    // Backend only exposes a Put operation (full replacement) — no Patch operation exists,
+    // so the upstream call uses PUT even though the BFF's own contract to the browser stays PATCH.
+    return authedBackend(\`/api/${entitiesKebab}/\${id}\`, {
+        method: 'PUT',
+        body: JSON.stringify(parsed.data)
+    });
+}
+
+export async function DELETE(request: NextRequest, context: Params) {
+    const badOrigin = validateOrigin(request);
+    if (badOrigin) return badOrigin;
+    const { id } = await context.params;
+    if (!validId(id)) return jsonProblem(404, { title: 'Not Found' });
+    return authedBackend(\`/api/${entitiesKebab}/\${id}\`, { method: 'DELETE' });
+}
+
+export const dynamic = 'force-dynamic';
+export const revalidate = 0;
+`;
+}
+export function exportRoute(spec, names) {
+    const { entityPascal, entitiesPascal, entitiesKebab } = names;
+    const field = searchField(spec);
+    const cols = displayFields(spec).map((f) => f.name);
+    if (null !== spec.timestampField && !cols.includes(spec.timestampField)) {
+        cols.push(spec.timestampField);
+    }
+    const fieldsByName = new Map(spec.fields.map((f) => [f.name, f]));
+    const exportFieldsType = cols
+        .map((c) => `    ${c}: ${c === spec.timestampField ? 'string' : tsType(fieldsByName.get(c) ?? { type: 'text' })};`)
+        .join('\n');
+    const guardLines = cols.flatMap((c) => {
+        const t = c === spec.timestampField ? 'string' : tsType(fieldsByName.get(c) ?? { type: 'text' });
+        return [`'${c}' in value`, `typeof value.${c} === '${t}'`];
+    });
+    const guardChecks = guardLines.map((line, i) => `        ${line}${i < guardLines.length - 1 ? ' &&' : ''}`).join('\n');
+    return `import { type NextRequest, NextResponse } from 'next/server';
+import { authedBackend } from '@/lib/bff';
+import { jsonProblem } from '@/lib/http';
+import { build${entitiesPascal}Csv } from '@/lib/${entitiesKebab}-csv';
+import { parse${entitiesPascal}Query } from '@/lib/${entitiesKebab}-query';
+
+type Export${entityPascal} = {
+${exportFieldsType}
+};
+
+type Export${entitiesPascal}Collection = {
+    totalItems: number;
+    member: Export${entityPascal}[];
+};
+
+function isExport${entityPascal}(value: unknown): value is Export${entityPascal} {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+${guardChecks}
+    );
+}
+
+function isExport${entitiesPascal}Collection(value: unknown): value is Export${entitiesPascal}Collection {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        'totalItems' in value &&
+        typeof value.totalItems === 'number' &&
+        Number.isSafeInteger(value.totalItems) &&
+        0 <= value.totalItems &&
+        'member' in value &&
+        Array.isArray(value.member) &&
+        value.member.every(isExport${entityPascal})
+    );
+}
+
+function buildExportPath(${field ? 'search: string' : ''}): string {
+${field ? `    const params = new URLSearchParams();
+    if (search) params.set('search', search);
+    const query = params.toString();
+    return query
+        ? \`/api/${entitiesKebab}/export-data?\${query}\`
+        : '/api/${entitiesKebab}/export-data';` : `    return '/api/${entitiesKebab}/export-data';`}
+}
+
+export async function GET(request: NextRequest): Promise<Response> {
+    try {
+${field ? `        const { search } = parse${entitiesPascal}Query(request.nextUrl.searchParams);
+        const response = await authedBackend(buildExportPath(search));` : `        const response = await authedBackend(buildExportPath());`}
+        if (!response.ok) return response;
+
+        const data: unknown = await response.json();
+        if (!isExport${entitiesPascal}Collection(data)) throw new Error('Invalid export data');
+
+        const date = new Date().toISOString().slice(0, 10);
+        return new NextResponse(build${entitiesPascal}Csv(data.member), {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/csv; charset=utf-8',
+                'Content-Disposition': \`attachment; filename="${entitiesKebab}-export-all-\${date}.csv"\`,
+                'Cache-Control': 'no-store'
+            }
+        });
+    } catch {
+        return jsonProblem(502, {
+            title: 'Bad Gateway',
+            detail: 'Unexpected ${entitiesKebab} response.'
+        });
+    }
+}
+
+export const dynamic = 'force-dynamic';
+export const revalidate = 0;
+`;
+}

package/dist/templates/csvLib.js

@@ -0,0 +1,30 @@
+import { displayFields, humanize } from '../naming.js';
+export function csvLib(spec, names) {
+    const { entityPascal, entitiesPascal, entitiesCamel } = names;
+    const fields = displayFields(spec).map((f) => f.name);
+    if (null !== spec.timestampField)
+        fields.push(spec.timestampField);
+    const pickList = fields.map((f) => `'${f}'`).join(' | ');
+    const header = fields.map((f) => humanize(f)).join(',');
+    const row = fields.map((f) => `toCsvField(String(item.${f}))`).join(', ');
+    return `import type { ${entityPascal} } from '@/types/api';
+
+const CSV_FORMULA_PREFIX = /^[\\s\\p{Cc}]*[=+\\-@]/u;
+const CSV_SPECIAL_CHARACTER = /[",\\r\\n]/;
+
+type Csv${entityPascal} = Pick<${entityPascal}, ${pickList}>;
+
+export function toCsvField(value: string): string {
+    const safeValue = CSV_FORMULA_PREFIX.test(value) ? \`'\${value}\` : value;
+    return CSV_SPECIAL_CHARACTER.test(safeValue)
+        ? \`"\${safeValue.replaceAll('"', '""')}"\`
+        : safeValue;
+}
+
+export function build${entitiesPascal}Csv(${entitiesCamel}: readonly Csv${entityPascal}[]): string {
+    const rows = ${entitiesCamel}.map((item) => [${row}].join(','));
+
+    return \`\\uFEFF\${['${header}', ...rows].join('\\r\\n')}\`;
+}
+`;
+}