@pattern-stack/codegen 0.2.0

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

@@ -0,0 +1,248 @@
+---
+to: "<%= generate.drizzleSchema ? outputPaths.drizzleSchema : '' %>"
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+/**
+ * <%= className %> Drizzle Schema
+ * Generated by entity codegen - do not edit directly
+ */
+
+<% if (hasRelationships) { -%>
+import { relations } from 'drizzle-orm';
+<% } -%>
+<%
+// Database dialect-specific imports
+const isPostgres = databaseDialect === 'postgres';
+const isSqlite = databaseDialect === 'sqlite';
+const dbCore = isPostgres ? 'drizzle-orm/pg-core' : 'drizzle-orm/sqlite-core';
+
+// Map Postgres imports to SQLite equivalents
+const sqliteImportMap = {
+  'pgTable': 'sqliteTable',
+  'pgEnum': 'text', // SQLite doesn't have native enums
+  'uuid': 'text',
+  'varchar': 'text',
+  'numeric': 'real',
+  'timestamp': 'integer', // Use Unix timestamps for SQLite
+  'date': 'text', // ISO 8601 date strings
+  'jsonb': 'text', // JSON as text in SQLite
+  'boolean': 'integer', // 0/1 in SQLite
+  'integer': 'integer',
+  'text': 'text',
+};
+
+// Get imports based on dialect
+const dialectImports = isSqlite
+  ? [...new Set(drizzleImports.map(imp => sqliteImportMap[imp] || imp))]
+  : drizzleImports;
+
+// Determine if we need index import
+const needsIndex = hasEntityRefFields || belongsToRelations.length > 0 || fields.some(f => f.index);
+-%>
+import {
+<% dialectImports.forEach((imp) => { -%>
+	<%= imp %>,
+<% }) -%>
+<% if (needsIndex) { -%>
+	index,
+<% } -%>
+} from '<%= dbCore %>';
+<%
+// Collect unique non-self-referential schema imports
+const importedSchemas = new Set();
+[...belongsToRelations, ...hasManyRelations, ...hasOneRelations].forEach((rel) => {
+  if (rel.targetPlural !== plural) {
+    importedSchemas.add(rel.targetPlural);
+  }
+});
+-%>
+<% importedSchemas.forEach((targetPlural) => { -%>
+import { <%= targetPlural %> } from './<%= targetPlural %>.schema';
+<% }) -%>
+<% if (hasEntityRefFields) { -%>
+import { entityTypeEnum } from './entity-types.schema';
+<% } -%>
+<% if (enumFields.length > 0 && isPostgres) { -%>
+
+// Enum definitions (Postgres only)
+<% enumFields.forEach((field) => { -%>
+export const <%= field.enumName %> = pgEnum('<%= field.name %>', [<%- field.choices.map(c => `'${c}'`).join(', ') %>]);
+<% }) -%>
+<% } -%>
+<%
+// Table function name based on dialect
+const tableFunc = isPostgres ? 'pgTable' : 'sqliteTable';
+-%>
+
+export const <%= plural %> = <%= tableFunc %>('<%= table %>', {
+<% if (isPostgres) { -%>
+	id: uuid('id').defaultRandom().primaryKey(),
+<% } else { -%>
+	id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+<% } -%>
+<% fields.forEach((field) => { -%>
+<% const colName = field.name.replace(/([A-Z])/g, '_$1').toLowerCase(); -%>
+<% // Check if this field is a FK for a belongs_to relationship -%>
+<% const belongsToRel = belongsToRelations.find(r => r.foreignKeyCamel === field.camelName); -%>
+<% if (field.drizzleType === 'entity_type_enum') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: entityTypeEnum('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } -%>
+<% } else if (field.drizzleType === 'text_array') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: text('<%= colName %>').array()<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>, // JSON array in SQLite
+<% } -%>
+<% } else if (field.drizzleType === 'enum') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: <%= field.enumName %>('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>, // Enum as text in SQLite
+<% } -%>
+<% } else if (field.drizzleType === 'varchar') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: varchar('<%= colName %>'<%= field.maxLength ? `, { length: ${field.maxLength} }` : '' %>)<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.unique ? '.unique()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.unique ? '.unique()' : '' %>,
+<% } -%>
+<% } else if (field.drizzleType === 'uuid') { -%>
+<% if (belongsToRel) { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: uuid('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>.references(() => <%= belongsToRel.targetPlural %>.id),
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>.references(() => <%= belongsToRel.targetPlural %>.id),
+<% } -%>
+<% } else { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: uuid('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.unique ? '.unique()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.unique ? '.unique()' : '' %>,
+<% } -%>
+<% } -%>
+<% } else if (field.drizzleType === 'integer') { -%>
+	<%= field.camelName %>: integer('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else if (field.drizzleType === 'decimal') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: numeric('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: real('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } -%>
+<% } else if (field.drizzleType === 'boolean') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: boolean('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.default !== undefined ? `.default(${field.default})` : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: integer('<%= colName %>', { mode: 'boolean' })<%= field.required && !field.nullable ? '.notNull()' : '' %><%= field.default !== undefined ? `.default(${field.default ? 1 : 0})` : '' %>,
+<% } -%>
+<% } else if (field.drizzleType === 'date') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: date('<%= colName %>', { mode: 'date' })<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>, // ISO 8601 date string
+<% } -%>
+<% } else if (field.drizzleType === 'timestamp') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: timestamp('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: integer('<%= colName %>', { mode: 'timestamp' })<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } -%>
+<% } else if (field.drizzleType === 'jsonb') { -%>
+<% if (isPostgres) { -%>
+	<%= field.camelName %>: jsonb('<%= colName %>')<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } else { -%>
+	<%= field.camelName %>: text('<%= colName %>', { mode: 'json' })<%= field.required && !field.nullable ? '.notNull()' : '' %>,
+<% } -%>
+<% } -%>
+<% }) -%>
+<% /* ================================================================== */ -%>
+<% /* Behavior fields - generated based on behaviors array               */ -%>
+<% /* ================================================================== */ -%>
+<% if (hasTimestamps) { -%>
+	// timestamps behavior
+<% if (isPostgres) { -%>
+	createdAt: timestamp('created_at').defaultNow().notNull(),
+	updatedAt: timestamp('updated_at').defaultNow().notNull(),
+<% } else { -%>
+	createdAt: integer('created_at', { mode: 'timestamp' }).$defaultFn(() => new Date()).notNull(),
+	updatedAt: integer('updated_at', { mode: 'timestamp' }).$defaultFn(() => new Date()).notNull(),
+<% } -%>
+<% } -%>
+<% if (hasSoftDelete) { -%>
+	// soft_delete behavior
+<% if (isPostgres) { -%>
+	deletedAt: timestamp('deleted_at'),
+<% } else { -%>
+	deletedAt: integer('deleted_at', { mode: 'timestamp' }),
+<% } -%>
+<% } -%>
+<% if (hasUserTracking) { -%>
+	// user_tracking behavior
+<% if (isPostgres) { -%>
+	createdBy: uuid('created_by'),
+	updatedBy: uuid('updated_by'),
+<% } else { -%>
+	createdBy: text('created_by'),
+	updatedBy: text('updated_by'),
+<% } -%>
+<% } -%>
+<% if (hasTemporalValidity) { -%>
+	// temporal_validity behavior
+<% if (isPostgres) { -%>
+	validFrom: timestamp('valid_from'),
+	validTo: timestamp('valid_to'),
+	isActive: boolean('is_active').default(true).notNull(),
+<% } else { -%>
+	validFrom: integer('valid_from', { mode: 'timestamp' }),
+	validTo: integer('valid_to', { mode: 'timestamp' }),
+	isActive: integer('is_active', { mode: 'boolean' }).default(1).notNull(),
+<% } -%>
+<% } -%>
+}<%
+// Determine if we need a table config function for indexes
+const fkIndexes = belongsToRelations.map(rel => ({
+  name: rel.foreignKeyCamel,
+  colName: rel.foreignKey.replace(/([A-Z])/g, '_$1').toLowerCase()
+}));
+const fieldIndexes = fields.filter(f => f.index).map(f => ({
+  name: f.camelName,
+  colName: f.name.replace(/([A-Z])/g, '_$1').toLowerCase()
+}));
+const allIndexes = [...fkIndexes, ...fieldIndexes];
+const hasTableConfig = hasEntityRefFields || allIndexes.length > 0;
+-%>
+<% if (hasTableConfig) { -%>, (table) => ({
+<% entityRefFields.forEach((ref) => { -%>
+	<%= ref.camelName %>Idx: index('idx_<%= table %>_<%= ref.name %>').on(table.<%= ref.camelName %>EntityType, table.<%= ref.camelName %>EntityId),
+<% }) -%>
+<% allIndexes.forEach((idx) => { -%>
+	<%= idx.name %>Idx: index('idx_<%= table %>_<%= idx.colName %>').on(table.<%= idx.name %>),
+<% }) -%>
+})<% } -%>);
+<% if (hasRelationships) { -%>
+<%
+const usesOne = belongsToRelations.length > 0 || hasOneRelations.length > 0;
+const usesMany = hasManyRelations.length > 0;
+const destructured = [usesOne ? 'one' : '', usesMany ? 'many' : ''].filter(Boolean).join(', ');
+-%>
+
+export const <%= plural %>Relations = relations(<%= plural %>, ({ <%= destructured %> }) => ({
+<% belongsToRelations.forEach((rel) => { -%>
+	<%= rel.name %>: one(<%= rel.targetPlural %>, {
+		fields: [<%= plural %>.<%= rel.foreignKeyCamel %>],
+		references: [<%= rel.targetPlural %>.id],
+	}),
+<% }) -%>
+<% hasManyRelations.forEach((rel) => { -%>
+	<%= rel.name %>: many(<%= rel.targetPlural %>),
+<% }) -%>
+<% hasOneRelations.forEach((rel) => { -%>
+	<%= rel.name %>: one(<%= rel.targetPlural %>),
+<% }) -%>
+}));
+<% } -%>
+
+export type <%= className %>Record = typeof <%= plural %>.$inferSelect;
+export type New<%= className %>Record = typeof <%= plural %>.$inferInsert;

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

@@ -0,0 +1,12 @@
+---
+to: "<%= isCleanArchitecture ? `${basePaths.backendSrc}/${backendLayers.domain}/index.ts` : '' %>"
+inject: true
+append: true
+skip_if: <%= name %>
+---
+<% if (isNested) { -%>
+export * from './<%= name %>';
+<% } else { -%>
+export * from './<%= name %>.entity';
+export * from './<%= name %>.repository.interface';
+<% } -%>

package/templates/entity/new/backend/domain/entity.ejs.t

@@ -0,0 +1,108 @@
+---
+to: <%= outputPaths.entity %>
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.entity) { -%>
+/**
+ * <%= className %> Domain Entity
+ * Generated by entity codegen - do not edit directly
+ *
+ * NOTE: Related entity imports assume a nested folder structure where each entity
+ * lives in its own folder (e.g., domain/{entity}/{entity}.entity.ts). This follows
+ * CLEAN architecture conventions where each aggregate root has its own bounded context.
+ * All entities should follow this structure for consistent imports.
+ */
+<% if (hasEntityRefFields) { -%>
+import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
+<% } -%>
+<%
+// Collect unique non-self-referential imports
+const importedEntities = new Set();
+[...belongsToRelations, ...hasManyRelations, ...hasOneRelations].forEach((rel) => {
+  if (rel.target !== name) {
+    importedEntities.add(rel.target);
+  }
+});
+-%>
+<% if (importedEntities.size > 0) { -%>
+
+<% importedEntities.forEach((target) => {
+  const targetClass = target.charAt(0).toUpperCase() + target.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+-%>
+import type { <%= targetClass %> } from '../<%= target %>/<%= target %>.entity';
+<% }) -%>
+<% } -%>
+
+export class <%= className %> {
+	constructor(
+		public readonly id: string,
+<% fields.forEach((field) => { -%>
+		public readonly <%= field.camelName %>: <%- field.tsType %><%= field.nullable ? ' | null' : '' %>,
+<% }) -%>
+<% if (hasTimestamps) { -%>
+		public readonly createdAt: Date,
+		public readonly updatedAt: Date,
+<% } -%>
+<% if (hasSoftDelete) { -%>
+		public readonly deletedAt: Date | null,
+<% } -%>
+<% if (hasTemporalValidity) { -%>
+		public readonly validFrom: Date | null,
+		public readonly validTo: Date | null,
+		public readonly isActive: boolean,
+<% } -%>
+<% if (hasRelationships) { -%>
+		// Loaded relations (optional, populated when eager-loaded)
+<% belongsToRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>,
+<% }) -%>
+<% hasManyRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>[],
+<% }) -%>
+<% hasOneRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>,
+<% }) -%>
+<% } -%>
+	) {}
+
+	static fromRecord(
+		// biome-ignore lint/suspicious/noExplicitAny: Drizzle records have dynamic shape
+		record: Record<string, any>,
+<% if (hasRelationships) { -%>
+		// biome-ignore lint/suspicious/noExplicitAny: Returns different entity types
+		mapRelation?: (name: string, data: unknown) => any,
+<% } -%>
+	): <%= className %> {
+		return new <%= className %>(
+			record.id,
+<% fields.forEach((field) => { -%>
+			record.<%= field.camelName %>,
+<% }) -%>
+<% if (hasTimestamps) { -%>
+			record.createdAt,
+			record.updatedAt,
+<% } -%>
+<% if (hasSoftDelete) { -%>
+			record.deletedAt,
+<% } -%>
+<% if (hasTemporalValidity) { -%>
+			record.validFrom,
+			record.validTo,
+			record.isActive,
+<% } -%>
+<% if (hasRelationships) { -%>
+<% belongsToRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% hasManyRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% hasOneRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% } -%>
+		);
+	}
+}
+<% } -%>

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

@@ -0,0 +1,163 @@
+---
+to: <%= outputPaths.domainGroupedIndex %>
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.domainGroupedIndex) { -%>
+/**
+ * <%= className %> Domain Module
+ * Generated by entity codegen - do not edit directly
+ *
+ * This file contains the domain entity and repository interface
+ * using grouped file layout (file_grouping: "grouped")
+ */
+<% if (hasEntityRefFields) { -%>
+import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
+<% } -%>
+<%
+// Collect unique non-self-referential imports
+const importedEntities = new Set();
+[...belongsToRelations, ...hasManyRelations, ...hasOneRelations].forEach((rel) => {
+  if (rel.target !== name) {
+    importedEntities.add(rel.target);
+  }
+});
+-%>
+<% if (importedEntities.size > 0) { -%>
+
+<% importedEntities.forEach((target) => {
+  const targetClass = target.charAt(0).toUpperCase() + target.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+-%>
+import type { <%= targetClass %> } from '../<%= target %>';
+<% }) -%>
+<% } -%>
+
+// ============================================================================
+// Entity
+// ============================================================================
+
+export class <%= className %> {
+	constructor(
+		public readonly id: string,
+<% fields.forEach((field) => { -%>
+		public readonly <%= field.camelName %>: <%- field.tsType %><%= field.nullable ? ' | null' : '' %>,
+<% }) -%>
+<% if (hasTimestamps) { -%>
+		public readonly createdAt: Date,
+		public readonly updatedAt: Date,
+<% } -%>
+<% if (hasSoftDelete) { -%>
+		public readonly deletedAt: Date | null,
+<% } -%>
+<% if (hasTemporalValidity) { -%>
+		public readonly validFrom: Date | null,
+		public readonly validTo: Date | null,
+		public readonly isActive: boolean,
+<% } -%>
+<% if (hasRelationships) { -%>
+		// Loaded relations (optional, populated when eager-loaded)
+<% belongsToRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>,
+<% }) -%>
+<% hasManyRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>[],
+<% }) -%>
+<% hasOneRelations.forEach((rel) => { -%>
+		public readonly <%= rel.name %>?: <%= rel.targetClass %>,
+<% }) -%>
+<% } -%>
+	) {}
+
+	static fromRecord(
+		// biome-ignore lint/suspicious/noExplicitAny: Drizzle records have dynamic shape
+		record: Record<string, any>,
+<% if (hasRelationships) { -%>
+		// biome-ignore lint/suspicious/noExplicitAny: Returns different entity types
+		mapRelation?: (name: string, data: unknown) => any,
+<% } -%>
+	): <%= className %> {
+		return new <%= className %>(
+			record.id,
+<% fields.forEach((field) => { -%>
+			record.<%= field.camelName %>,
+<% }) -%>
+<% if (hasTimestamps) { -%>
+			record.createdAt,
+			record.updatedAt,
+<% } -%>
+<% if (hasSoftDelete) { -%>
+			record.deletedAt,
+<% } -%>
+<% if (hasTemporalValidity) { -%>
+			record.validFrom,
+			record.validTo,
+			record.isActive,
+<% } -%>
+<% if (hasRelationships) { -%>
+<% belongsToRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% hasManyRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% hasOneRelations.forEach((rel) => { -%>
+			record.<%= rel.name %> ? mapRelation?.('<%= rel.name %>', record.<%= rel.name %>) : undefined,
+<% }) -%>
+<% } -%>
+		);
+	}
+}
+
+// ============================================================================
+// Repository Interface
+// ============================================================================
+<% if (hasRelationships) { -%>
+
+/**
+ * Type-safe eager loading options.
+ * Pass to repository methods to include related entities.
+ */
+export type <%= className %>With = {
+<% relationships.forEach((rel) => { -%>
+	<%= rel.name %>?: boolean;
+<% }) -%>
+};
+<% } -%>
+
+/**
+ * Domain-level input types for repository operations.
+ */
+export type Create<%= className %>Input = {
+<% fields.forEach((field) => { -%>
+<% if (field.required) { -%>
+	<%= field.camelName %>: <%- field.tsType %>;
+<% } else if (field.nullable) { -%>
+	<%= field.camelName %>?: <%- field.tsType %> | null;
+<% } else { -%>
+	<%= field.camelName %>?: <%- field.tsType %>;
+<% } -%>
+<% }) -%>
+};
+
+export type Update<%= className %>Input = Partial<Create<%= className %>Input>;
+
+export interface I<%= className %>Repository {
+	create(input: Create<%= className %>Input): Promise<<%= className %>>;
+	findById(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %> | null>;
+	findAll(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+	update(id: string, input: Update<%= className %>Input): Promise<<%= className %> | null>;
+	delete(id: string): Promise<<%= className %> | null>;
+<% if (hasSoftDelete) { -%>
+	// Soft delete recovery methods
+	restore(id: string): Promise<<%= className %> | null>;
+	findWithDeleted(): Promise<<%= className %>[]>;
+	findOnlyDeleted(): Promise<<%= className %>[]>;
+<% } -%>
+<% belongsToRelations.forEach((rel) => { -%>
+	findBy<%= rel.foreignKeyPascal %>(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+<% }) -%>
+<% entityRefFields.forEach((ref) => { -%>
+	findBy<%= ref.pascalName %>(entityType: EntityType, entityId: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+<% }) -%>
+}
+<% } -%>

package/templates/entity/new/backend/domain/index.ejs.t

@@ -0,0 +1,15 @@
+---
+to: <%= basePaths.backendSrc %>/<%= paths.domain %>/index.ts
+skip_if: <%= !isCleanArchitecture || (!isNested || isGrouped) %>
+force: true
+---
+/**
+ * <%= className %> Domain Barrel Export
+ * Generated by entity codegen - do not edit directly
+ *
+ * This barrel file exports the entity and repository interface
+ * when using separate file layout (file_grouping: "separate")
+ */
+
+export * from './<%= name %>.entity';
+export * from './<%= name %>.repository.interface';

package/templates/entity/new/backend/domain/repository-interface.ejs.t

@@ -0,0 +1,71 @@
+---
+to: <%= outputPaths.repositoryInterface %>
+skip_if: <%= !isCleanArchitecture %>
+force: true
+---
+<% if (outputPaths.repositoryInterface) { -%>
+/**
+ * <%= className %> Repository Interface
+ * Generated by entity codegen - do not edit directly
+ */
+
+import type { <%= className %> } from './<%= name %>.entity';
+<% if (hasEntityRefFields) { -%>
+import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
+<% } -%>
+<% if (hasRelationships) { -%>
+
+/**
+ * Type-safe eager loading options.
+ * Pass to repository methods to include related entities.
+ */
+export type <%= className %>With = {
+<% relationships.forEach((rel) => { -%>
+	<%= rel.name %>?: boolean;
+<% }) -%>
+};
+<% } -%>
+
+/**
+ * Domain-level input types for repository operations.
+ */
+export type Create<%= className %>Input = {
+<% fields.forEach((field) => { -%>
+<% if (field.required) { -%>
+	<%= field.camelName %>: <%- field.tsType %>;
+<% } else if (field.nullable) { -%>
+	<%= field.camelName %>?: <%- field.tsType %> | null;
+<% } else { -%>
+	<%= field.camelName %>?: <%- field.tsType %>;
+<% } -%>
+<% }) -%>
+};
+
+export type Update<%= className %>Input = Partial<Create<%= className %>Input>;
+
+export interface I<%= className %>Repository {
+	create(input: Create<%= className %>Input): Promise<<%= className %>>;
+	findById(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %> | null>;
+	findAll(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+	update(id: string, input: Update<%= className %>Input): Promise<<%= className %> | null>;
+	delete(id: string): Promise<<%= className %> | null>;
+<% if (hasSoftDelete) { -%>
+	// Soft delete recovery methods
+	restore(id: string): Promise<<%= className %> | null>;
+	findWithDeleted(): Promise<<%= className %>[]>;
+	findOnlyDeleted(): Promise<<%= className %>[]>;
+<% } -%>
+<% belongsToRelations.forEach((rel) => { -%>
+	findBy<%= rel.foreignKeyPascal %>(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+<% }) -%>
+<% entityRefFields.forEach((ref) => { -%>
+	findBy<%= ref.pascalName %>(entityType: EntityType, entityId: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
+<% }) -%>
+<% if (hasDeclarativeQueries) { -%>
+	// Declarative queries (from queries: block in entity YAML)
+<% processedQueries.forEach((q) => { -%>
+	<%= q.methodName %>(<%- q.params.map(p => `${p.camelName}: ${p.tsType}`).join(', ') %>): Promise<<%- q.returnType %>>;
+<% }) -%>
+<% } -%>
+}
+<% } -%>

package/templates/entity/new/backend/modules/core/_ensure-anchor-tokens.ejs.t

@@ -0,0 +1,10 @@
+---
+to: "<%= isCleanArchitecture ? (exposeRepository ? `${locations.backendConstants.path}/tokens.ts` : '') : '' %>"
+inject: true
+append: true
+skip_if: "// Generated entity repository tokens"
+---
+<% if (exposeRepository) { -%>
+
+// Generated entity repository tokens
+<% } -%>

package/templates/entity/new/backend/modules/core/_inject-token.ejs.t

@@ -0,0 +1,7 @@
+---
+to: "<%= isCleanArchitecture ? `${locations.backendConstants.path}/tokens.ts` : '' %>"
+inject: true
+append: true
+skip_if: <%= repositoryToken %>
+---
+export const <%= repositoryToken %> = Symbol('<%= repositoryToken %>');