@pattern-stack/codegen 0.2.0

package/templates/entity/new/backend/application/queries/grouped-index.ejs.t

@@ -0,0 +1,81 @@
+---
+to: "<%= generate.queries ? outputPaths.queriesGroupedIndex : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.queriesGroupedIndex) { -%>
+/**
+ * <%= className %> Queries Module
+ * Generated by entity codegen - do not edit directly
+ *
+ * This file contains all query handlers for <%= className %>
+ * using grouped file layout (file_grouping: "grouped")
+ */
+
+import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { <%= repositoryToken %> } from '<%= imports.constants %>';
+import type { I<%= className %>Repository<%= hasRelationships ? `, ${className}With` : '' %> } from '<%= imports.domain %>';
+import { <%= className %> } from '<%= imports.domain %>';
+
+// ============================================================================
+// Get <%= className %> By ID Query
+// ============================================================================
+
+/**
+ * Get <%= className %> By ID Query
+ * Generated by entity codegen - do not edit directly
+ *
+ * EXTENSION POINTS (add query logic here):
+ * - Authorization: Check if user can access this specific record
+ * - Enrichment: Add computed fields or related data
+ * - Caching: Add cache layer for frequently accessed records
+ */
+@Injectable()
+export class <%= getByIdQueryClass %> {
+	constructor(
+		@Inject(<%= repositoryToken %>)
+		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+	) {}
+
+	async execute(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>> {
+		// TODO: Add authorization check if needed (row-level security)
+
+		const entity = await this.<%= camelName %>Repository.findById(id<%= hasRelationships ? ', include' : '' %>);
+		if (!entity) {
+			throw new NotFoundException(`<%= className %> with id ${id} not found`);
+		}
+
+		// TODO: Add enrichment or computed fields if needed
+
+		return entity;
+	}
+}
+
+// ============================================================================
+// List <%= classNamePlural %> Query
+// ============================================================================
+
+/**
+ * List <%= classNamePlural %> Query
+ * Generated by entity codegen - do not edit directly
+ *
+ * EXTENSION POINTS (add query logic here):
+ * - Filtering: Add where clauses based on query parameters
+ * - Authorization: Filter results based on user permissions (row-level security)
+ * - Pagination: Add limit/offset or cursor-based pagination
+ * - Sorting: Add order by clauses
+ * - Caching: Add cache layer for frequently accessed lists
+ */
+@Injectable()
+export class <%= listQueryClass %> {
+	constructor(
+		@Inject(<%= repositoryToken %>)
+		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+	) {}
+
+	async execute(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]> {
+		// TODO: Add filtering, pagination, sorting as needed
+		return this.<%= camelName %>Repository.findAll(<%= hasRelationships ? 'include' : '' %>);
+	}
+}
+<% } -%>

package/templates/entity/new/backend/application/queries/index.ejs.t

@@ -0,0 +1,14 @@
+---
+to: "<%= generate.queries ? outputPaths.queriesIndex : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.queriesIndex) { -%>
+/**
+ * <%= className %> Queries Barrel Export
+ * Generated by entity codegen - do not edit directly
+ */
+
+export * from './<%= fileNames.getByIdQuery.replace('.ts', '') %>';
+export * from './<%= fileNames.listQuery.replace('.ts', '') %>';
+<% } -%>

package/templates/entity/new/backend/application/queries/list.ejs.t

@@ -0,0 +1,36 @@
+---
+to: "<%= generate.queries ? outputPaths.listQuery : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.listQuery) { -%>
+/**
+ * List <%= classNamePlural %> Query
+ * Generated by entity codegen - do not edit directly
+ *
+ * EXTENSION POINTS (add query logic here):
+ * - Filtering: Add where clauses based on query parameters
+ * - Authorization: Filter results based on user permissions (row-level security)
+ * - Pagination: Add limit/offset or cursor-based pagination
+ * - Sorting: Add order by clauses
+ * - Caching: Add cache layer for frequently accessed lists
+ */
+
+import { Inject, Injectable } from '@nestjs/common';
+import { <%= repositoryToken %> } from '<%= imports.constants %>';
+import type { I<%= className %>Repository<%= hasRelationships ? `, ${className}With` : '' %> } from '<%= imports.domain %>';
+import { <%= className %> } from '<%= imports.domain %>';
+
+@Injectable()
+export class <%= listQueryClass %> {
+	constructor(
+		@Inject(<%= repositoryToken %>)
+		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+	) {}
+
+	async execute(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]> {
+		// TODO: Add filtering, pagination, sorting as needed
+		return this.<%= camelName %>Repository.findAll(<%= hasRelationships ? 'include' : '' %>);
+	}
+}
+<% } -%>

package/templates/entity/new/backend/application/schemas/_inject-index.ejs.t

@@ -0,0 +1,7 @@
+---
+to: "<%= isCleanArchitecture ? (generate.dtos ? `${basePaths.backendSrc}/${backendLayers.schemas}/index.ts` : '') : '' %>"
+inject: true
+append: true
+skip_if: <%= name %>.dto
+---
+export * from './<%= name %>.dto';

package/templates/entity/new/backend/application/schemas/dto.ejs.t

@@ -0,0 +1,45 @@
+---
+to: "<%= generate.dtos ? outputPaths.dto : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+/**
+ * <%= className %> DTOs
+ * Generated by entity codegen - do not edit directly
+ */
+
+import { z } from 'zod';
+<% if (hasEntityRefFields) { -%>
+import { entityTypeSchema } from '<%= locations.dbContextEngine.import %>';
+<% } -%>
+
+export const create<%= className %>Schema = z.object({
+<% fields.forEach((field) => { -%>
+<% let zodChain = field.zodType; -%>
+<% if (field.type === 'string' && field.maxLength) { zodChain += `.max(${field.maxLength})`; } -%>
+<% if (field.type === 'string' && field.minLength) { zodChain += `.min(${field.minLength})`; } -%>
+<% if (['integer', 'decimal'].includes(field.type) && field.min !== undefined) { zodChain += `.min(${field.min})`; } -%>
+<% if (['integer', 'decimal'].includes(field.type) && field.max !== undefined) { zodChain += `.max(${field.max})`; } -%>
+<% if (field.choices) { zodChain = `z.enum([${field.choices.map(c => `'${c}'`).join(', ')}])`; } -%>
+<% if (field.nullable) { zodChain += '.nullable()'; } -%>
+<% if (!field.required) { zodChain += '.optional()'; } -%>
+	<%- field.camelName %>: <%- zodChain %>,
+<% }) -%>
+});
+
+export type Create<%= className %>Dto = z.infer<typeof create<%= className %>Schema>;
+
+export const update<%= className %>Schema = z.object({
+<% fields.forEach((field) => { -%>
+<% let zodChain = field.zodType; -%>
+<% if (field.type === 'string' && field.maxLength) { zodChain += `.max(${field.maxLength})`; } -%>
+<% if (field.type === 'string' && field.minLength) { zodChain += `.min(${field.minLength})`; } -%>
+<% if (['integer', 'decimal'].includes(field.type) && field.min !== undefined) { zodChain += `.min(${field.min})`; } -%>
+<% if (['integer', 'decimal'].includes(field.type) && field.max !== undefined) { zodChain += `.max(${field.max})`; } -%>
+<% if (field.choices) { zodChain = `z.enum([${field.choices.map(c => `'${c}'`).join(', ')}])`; } -%>
+<% if (field.nullable) { zodChain += '.nullable()'; } -%>
+	<%- field.camelName %>: <%- zodChain %>.optional(),
+<% }) -%>
+});
+
+export type Update<%= className %>Dto = z.infer<typeof update<%= className %>Schema>;

package/templates/entity/new/backend/database/_inject-index.ejs.t

@@ -0,0 +1,7 @@
+---
+to: "<%= isCleanArchitecture ? (generate.drizzleSchema ? `${basePaths.backendSrc}/${backendLayers.drizzle}/index.ts` : '') : '' %>"
+inject: true
+append: true
+skip_if: <%= plural %>.schema
+---
+export * from './<%= plural %>.schema';

package/templates/entity/new/backend/database/electric-migration.ejs.t

@@ -0,0 +1,21 @@
+---
+to: "<%= exposeElectric && databaseDialect === 'postgres' ? `${locations.dbMigrations.path}/${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}_Add${classNamePlural}ToElectric.sql` : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+-- Electric SQL setup for <%= table %>
+-- Generated by entity codegen
+
+-- Enable full row logging for Electric replication
+ALTER TABLE "<%= table %>" REPLICA IDENTITY FULL;
+
+-- Add table to Electric publication if not already a member
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_publication_tables
+        WHERE pubname = 'electric_publication_default' AND tablename = '<%= table %>'
+    ) THEN
+        ALTER PUBLICATION electric_publication_default ADD TABLE "<%= table %>";
+    END IF;
+END $$;

package/templates/entity/new/backend/database/repository.ejs.t

@@ -0,0 +1,450 @@
+---
+to: <%= basePaths.backendSrc %>/<%= paths.repositories %>/<%= name %>.repository.ts
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+/**
+ * <%= className %> Repository Implementation
+ * Generated by entity codegen - do not edit directly
+ */
+<% if (behaviorStrategy === 'base_class') { -%>
+
+import { Injectable } from '@nestjs/common';
+import { eq<%= (hasEntityRefFields || hasMultiFieldQuery) ? ', and' : '' %><%= hasOrderedQuery ? ', desc, asc' : '' %> } from 'drizzle-orm';
+import { BaseRepository, type BehaviorConfig } from '../base.repository';
+<% if (hasEntityRefFields) { -%>
+import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
+<% } -%>
+import type {
+	Create<%= className %>Input,
+	I<%= className %>Repository,
+	Update<%= className %>Input,
+<% if (hasRelationships) { -%>
+	<%= className %>With,
+<% } -%>
+} from '../../../domain';
+<%
+// Collect unique entity imports - only include relationships with existing target entities
+const entityImports = new Set([className]);
+if (hasExistingRelationships) {
+  [...existingBelongsTo, ...existingHasMany, ...existingHasOne].forEach((rel) => {
+    entityImports.add(rel.targetClass);
+  });
+}
+-%>
+import { <%- [...entityImports].join(', ') %> } from '../../../domain';
+import { <%= plural %> } from '<%= locations.dbSchemaServer.import %>';
+
+@Injectable()
+export class <%= className %>Repository
+	extends BaseRepository<
+		typeof <%= plural %>,
+		<%= className %>,
+		Create<%= className %>Input,
+		Update<%= className %>Input
+	>
+	implements I<%= className %>Repository
+{
+	protected readonly table = <%= plural %>;
+
+	// Behaviors declared in YAML -> generated as config object
+	protected readonly behaviors: BehaviorConfig = {
+		timestamps: <%= repositoryBehaviorConfig.timestamps %>,
+		softDelete: <%= repositoryBehaviorConfig.softDelete %>,
+		userTracking: <%= repositoryBehaviorConfig.userTracking %>,
+	};
+
+	protected toEntity(record: typeof <%= plural %>.$inferSelect): <%= className %> {
+		return <%= className %>.fromRecord(record);
+	}
+<% belongsToRelations.forEach((rel) => { -%>
+
+	async findBy<%= rel.foreignKeyPascal %>(id: string): Promise<<%= className %>[]> {
+		const records = await this.baseQuery()
+			.where(eq(this.table.<%= rel.foreignKeyCamel %>, id));
+		return records.map((r) => this.toEntity(r));
+	}
+<% }) -%>
+<% entityRefFields.forEach((ref) => { -%>
+
+	async findBy<%= ref.pascalName %>(entityType: EntityType, entityId: string): Promise<<%= className %>[]> {
+		const records = await this.baseQuery()
+			.where(
+				and(
+					eq(this.table.<%= ref.camelName %>EntityType, entityType),
+					eq(this.table.<%= ref.camelName %>EntityId, entityId)
+				)
+			);
+		return records.map((r) => this.toEntity(r));
+	}
+<% }) -%>
+<% if (hasDeclarativeQueries) { -%>
+
+	// ═══════════════════════════════════════════════════════════════════════
+	// Declarative queries (from queries: block in entity YAML)
+	// ═══════════════════════════════════════════════════════════════════════
+<% processedQueries.forEach((q) => { -%>
+
+	async <%= q.methodName %>(<%- q.params.map(p => `${p.camelName}: ${p.tsType}`).join(', ') %>): Promise<<%- q.returnType %>> {
+<% if (q.hasVia) { -%>
+		// Junction query through <%= q.viaTable %>
+		const junctionRecords = await this.baseQuery()
+			.innerJoin(<%= q.viaTableCamel %>, eq(<%= q.viaTableCamel %>.<%= name %>Id, this.table.id))
+			.where(<%= q.params.map(p => `eq(${q.viaTableCamel}.${p.camelName}, ${p.camelName})`).join(', ') %>);
+<% if (q.hasSelect) { -%>
+		return junctionRecords.map(r => r.<%= q.selectFields[0] %>);
+<% } else { -%>
+		return junctionRecords.map(r => this.toEntity(r));
+<% } -%>
+<% } else if (q.isUnique) { -%>
+		const records = await this.baseQuery()
+			.where(<%= q.hasMultipleParams ? 'and(' : '' %><%= q.params.map(p => `eq(this.table.${p.camelName}, ${p.camelName})`).join(', ') %><%= q.hasMultipleParams ? ')' : '' %>)
+			.limit(1);
+		return records[0] ? this.toEntity(records[0]) : null;
+<% } else { -%>
+		const records = await this.baseQuery()
+			.where(<%= q.hasMultipleParams ? 'and(' : '' %><%= q.params.map(p => `eq(this.table.${p.camelName}, ${p.camelName})`).join(', ') %><%= q.hasMultipleParams ? ')' : '' %>)<%= q.hasOrder ? `.orderBy(${q.orderDirection}(this.table.${q.orderBy}))` : '' %>;
+		return records.map(r => this.toEntity(r));
+<% } -%>
+	}
+<% }) -%>
+<% } -%>
+<% if (hasRelationships) { -%>
+
+	// ═══════════════════════════════════════════════════════════════════════
+	// Relationship loading (extends base class)
+	// ═══════════════════════════════════════════════════════════════════════
+
+	async findByIdWithRelations(
+		id: string,
+		include?: <%= className %>With,
+	): Promise<<%= className %> | null> {
+		const record = await this.db.query.<%= plural %>.findFirst({
+			where: eq(<%= plural %>.id, id),
+			with: this.buildWithClause(include),
+		});
+		return record ? this.mapToEntityWithRelations(record) : null;
+	}
+
+	async findAllWithRelations(include?: <%= className %>With): Promise<<%= className %>[]> {
+		const records = await this.db.query.<%= plural %>.findMany({
+			with: this.buildWithClause(include),
+		});
+		return records.map((r) => this.mapToEntityWithRelations(r));
+	}
+
+	private buildWithClause(include?: <%= className %>With) {
+		if (!include) return undefined;
+		const result: Record<string, true> = {};
+<% relationships.forEach((rel) => { -%>
+		if (include.<%= rel.name %>) result.<%= rel.name %> = true;
+<% }) -%>
+		return Object.keys(result).length > 0 ? result : undefined;
+	}
+
+	// biome-ignore lint/suspicious/noExplicitAny: Drizzle relational query returns dynamic shape
+	private mapToEntityWithRelations(record: any): <%= className %> {
+<% if (hasExistingRelationships) { -%>
+		return <%= className %>.fromRecord(record, (name, data) => {
+			switch (name) {
+<% existingBelongsTo.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle record
+					return <%= rel.targetClass %>.fromRecord(data as any);
+<% }) -%>
+<% existingHasMany.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle records
+					return (data as any[]).map((r) => <%= rel.targetClass %>.fromRecord(r));
+<% }) -%>
+<% existingHasOne.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle record
+					return <%= rel.targetClass %>.fromRecord(data as any);
+<% }) -%>
+				default:
+					return data;
+			}
+		});
+<% } else { -%>
+		// Related entities not yet generated - return entity without relationship mapping
+		return <%= className %>.fromRecord(record);
+<% } -%>
+	}
+<% } -%>
+}
+<% } else { -%>
+<%# ================================================================== -%>
+<%# INLINE STRATEGY - Full CRUD code generated directly                -%>
+<%# ================================================================== -%>
+
+import { Inject, Injectable } from '@nestjs/common';
+import { eq<%= hasSoftDelete ? ', isNull, isNotNull' : '' %><%= (hasEntityRefFields || hasMultiFieldQuery) ? ', and' : '' %><%= hasOrderedQuery ? ', desc, asc' : '' %> } from 'drizzle-orm';
+import { DRIZZLE } from '<%= imports.repositoryToConstants %>';
+<% if (hasEntityRefFields) { -%>
+import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
+<% } -%>
+import type {
+	Create<%= className %>Input,
+	I<%= className %>Repository,
+	Update<%= className %>Input,
+<% if (hasRelationships) { -%>
+	<%= className %>With,
+<% } -%>
+} from '../../../domain';
+<%
+// Collect unique entity imports - only include relationships with existing target entities
+const entityImports = new Set([className]);
+if (hasExistingRelationships) {
+  [...existingBelongsTo, ...existingHasMany, ...existingHasOne].forEach((rel) => {
+    entityImports.add(rel.targetClass);
+  });
+}
+-%>
+import { <%- [...entityImports].join(', ') %> } from '../../../domain';
+import type { DrizzleDB } from '../database.module';
+import { <%= plural %> } from '<%= locations.dbSchemaServer.import %>';
+
+@Injectable()
+export class <%= className %>Repository implements I<%= className %>Repository {
+	constructor(@Inject(DRIZZLE) private readonly db: DrizzleDB) {}
+
+	async create(input: Create<%= className %>Input): Promise<<%= className %>> {
+<% if (hasTimestamps) { -%>
+		const now = new Date();
+<% } -%>
+		const result = await this.db
+			.insert(<%= plural %>)
+			.values({
+<% fields.forEach((field) => { -%>
+				<%= field.camelName %>: input.<%= field.camelName %>,
+<% }) -%>
+<% if (hasTimestamps) { -%>
+				createdAt: now,
+				updatedAt: now,
+<% } -%>
+			})
+			.returning();
+
+		const record = result[0] as typeof <%= plural %>.$inferSelect;
+		return <%= className %>.fromRecord(record);
+	}
+
+	async findById(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %> | null> {
+<% if (hasRelationships) { -%>
+		const record = await this.db.query.<%= plural %>.findFirst({
+			where: eq(<%= plural %>.id, id),
+			with: this.buildWithClause(include),
+		});
+
+		return record ? this.mapToEntity(record) : null;
+<% } else { -%>
+		const result = await this.baseQuery()
+			.where(eq(<%= plural %>.id, id))
+			.limit(1);
+
+		const record = result[0];
+		return record ? <%= className %>.fromRecord(record) : null;
+<% } -%>
+	}
+
+	async findAll(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]> {
+<% if (hasRelationships) { -%>
+		const records = await this.db.query.<%= plural %>.findMany({
+			with: this.buildWithClause(include),
+		});
+
+		return records.map((r) => this.mapToEntity(r));
+<% } else { -%>
+		const records = await this.baseQuery();
+		return records.map(<%= className %>.fromRecord);
+<% } -%>
+	}
+
+	async update(id: string, input: Update<%= className %>Input): Promise<<%= className %> | null> {
+		const result = await this.db
+			.update(<%= plural %>)
+			.set({
+				...input,
+<% if (hasTimestamps) { -%>
+				updatedAt: new Date(),
+<% } -%>
+			})
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+
+		const record = result[0];
+		return record ? <%= className %>.fromRecord(record) : null;
+	}
+
+	async delete(id: string): Promise<<%= className %> | null> {
+<% if (hasSoftDelete) { -%>
+		// Soft delete - set deletedAt timestamp
+		const result = await this.db
+			.update(<%= plural %>)
+			.set({ deletedAt: new Date() })
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+<% } else { -%>
+		const result = await this.db
+			.delete(<%= plural %>)
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+<% } -%>
+
+		const record = result[0];
+		return record ? <%= className %>.fromRecord(record) : null;
+	}
+<% if (hasSoftDelete) { -%>
+
+	async restore(id: string): Promise<<%= className %> | null> {
+		const result = await this.db
+			.update(<%= plural %>)
+			.set({ deletedAt: null })
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+
+		const record = result[0];
+		return record ? <%= className %>.fromRecord(record) : null;
+	}
+
+	async findWithDeleted(): Promise<<%= className %>[]> {
+		const records = await this.db.select().from(<%= plural %>);
+		return records.map(<%= className %>.fromRecord);
+	}
+
+	async findOnlyDeleted(): Promise<<%= className %>[]> {
+		const records = await this.db
+			.select()
+			.from(<%= plural %>)
+			.where(isNotNull(<%= plural %>.deletedAt));
+		return records.map(<%= className %>.fromRecord);
+	}
+<% } -%>
+
+	private baseQuery() {
+<% if (hasSoftDelete) { -%>
+		return this.db.select().from(<%= plural %>).where(isNull(<%= plural %>.deletedAt));
+<% } else { -%>
+		return this.db.select().from(<%= plural %>);
+<% } -%>
+	}
+<% belongsToRelations.forEach((rel) => { -%>
+
+	async findBy<%= rel.foreignKeyPascal %>(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]> {
+<% if (hasRelationships) { -%>
+		const records = await this.db.query.<%= plural %>.findMany({
+			where: eq(<%= plural %>.<%= rel.foreignKeyCamel %>, id),
+			with: this.buildWithClause(include),
+		});
+
+		return records.map((r) => this.mapToEntity(r));
+<% } else { -%>
+		const records = await this.baseQuery()
+			.where(eq(<%= plural %>.<%= rel.foreignKeyCamel %>, id));
+
+		return records.map(<%= className %>.fromRecord);
+<% } -%>
+	}
+<% }) -%>
+<% entityRefFields.forEach((ref) => { -%>
+
+	async findBy<%= ref.pascalName %>(entityType: EntityType, entityId: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]> {
+<% if (hasRelationships) { -%>
+		const records = await this.db.query.<%= plural %>.findMany({
+			where: and(
+				eq(<%= plural %>.<%= ref.camelName %>EntityType, entityType),
+				eq(<%= plural %>.<%= ref.camelName %>EntityId, entityId)
+			),
+			with: this.buildWithClause(include),
+		});
+
+		return records.map((r) => this.mapToEntity(r));
+<% } else { -%>
+		const records = await this.baseQuery()
+			.where(
+				and(
+					eq(<%= plural %>.<%= ref.camelName %>EntityType, entityType),
+					eq(<%= plural %>.<%= ref.camelName %>EntityId, entityId)
+				)
+			);
+
+		return records.map(<%= className %>.fromRecord);
+<% } -%>
+	}
+<% }) -%>
+<% if (hasDeclarativeQueries) { -%>
+
+	// ═══════════════════════════════════════════════════════════════════════
+	// Declarative queries (from queries: block in entity YAML)
+	// ═══════════════════════════════════════════════════════════════════════
+<% processedQueries.forEach((q) => { -%>
+
+	async <%= q.methodName %>(<%- q.params.map(p => `${p.camelName}: ${p.tsType}`).join(', ') %>): Promise<<%- q.returnType %>> {
+<% if (q.hasVia) { -%>
+		// Junction query through <%= q.viaTable %>
+		const junctionRecords = await this.baseQuery()
+			.innerJoin(<%= q.viaTableCamel %>, eq(<%= q.viaTableCamel %>.<%= name %>Id, <%= plural %>.id))
+			.where(<%= q.params.map(p => `eq(${q.viaTableCamel}.${p.camelName}, ${p.camelName})`).join(', ') %>);
+<% if (q.hasSelect) { -%>
+		return junctionRecords.map(r => r.<%= q.selectFields[0] %>);
+<% } else { -%>
+		return junctionRecords.map(r => <%= className %>.fromRecord(r));
+<% } -%>
+<% } else if (q.isUnique) { -%>
+		const records = await this.baseQuery()
+			.where(<%= q.hasMultipleParams ? 'and(' : '' %><%= q.params.map(p => `eq(${plural}.${p.camelName}, ${p.camelName})`).join(', ') %><%= q.hasMultipleParams ? ')' : '' %>)
+			.limit(1);
+		return records[0] ? <%= className %>.fromRecord(records[0]) : null;
+<% } else { -%>
+		const records = await this.baseQuery()
+			.where(<%= q.hasMultipleParams ? 'and(' : '' %><%= q.params.map(p => `eq(${plural}.${p.camelName}, ${p.camelName})`).join(', ') %><%= q.hasMultipleParams ? ')' : '' %>)<%= q.hasOrder ? `.orderBy(${q.orderDirection}(${plural}.${q.orderBy}))` : '' %>;
+		return records.map(<%= className %>.fromRecord);
+<% } -%>
+	}
+<% }) -%>
+<% } -%>
+<% if (hasRelationships) { -%>
+
+	private buildWithClause(include?: <%= className %>With) {
+		if (!include) return undefined;
+		// Drizzle expects `true` or object, not `false`. Only include truthy values.
+		const result: Record<string, true> = {};
+<% relationships.forEach((rel) => { -%>
+		if (include.<%= rel.name %>) result.<%= rel.name %> = true;
+<% }) -%>
+		return Object.keys(result).length > 0 ? result : undefined;
+	}
+
+	// biome-ignore lint/suspicious/noExplicitAny: Drizzle relational query returns dynamic shape
+	private mapToEntity(record: any): <%= className %> {
+<% if (hasExistingRelationships) { -%>
+		return <%= className %>.fromRecord(record, (name, data) => {
+			switch (name) {
+<% existingBelongsTo.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle record
+					return <%= rel.targetClass %>.fromRecord(data as any);
+<% }) -%>
+<% existingHasMany.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle records
+					return (data as any[]).map((r) => <%= rel.targetClass %>.fromRecord(r));
+<% }) -%>
+<% existingHasOne.forEach((rel) => { -%>
+				case '<%= rel.name %>':
+					// biome-ignore lint/suspicious/noExplicitAny: Cast for Drizzle record
+					return <%= rel.targetClass %>.fromRecord(data as any);
+<% }) -%>
+				default:
+					return data;
+			}
+		});
+<% } else { -%>
+		// Related entities not yet generated - return entity without relationship mapping
+		return <%= className %>.fromRecord(record);
+<% } -%>
+	}
+<% } -%>
+}
+<% } -%>