@devstroupe/devkit-cli 1.0.0 → 1.1.0

package/dist/templates/angular/list.template.js

@@ -7,6 +7,18 @@ const relationships_1 = require("../shared/relationships");
 function angularListHtmlTemplate(name, properties, listType = 'table', formType = 'page', filterType = 'popover') {
     const pascalName = (0, names_1.kebabToPascal)(name);
     let listComponentHtml = '';
+    const currencyProperties = properties.filter((p) => p.type === 'currency');
+    const hasCurrency = currencyProperties.length > 0;
+    const customTemplatesAttr = hasCurrency
+        ? `\n    [customTemplates]="{ ${currencyProperties.map((p) => `${p.name}: ${p.name}Temp`).join(', ')} }"`
+        : '';
+    const templatesHtml = currencyProperties
+        .map((p) => `
+
+<ng-template #${p.name}Temp let-row>
+  {{ row.${p.name} | currency:'BRL':'symbol':'1.2-2' }}
+</ng-template>`)
+        .join('');
     if (listType === 'card') {
         listComponentHtml = `  <!-- Lista em Cards Dinâmica -->
   <devkit-card-list
@@ -32,8 +44,8 @@ function angularListHtmlTemplate(name, properties, listType = 'table', formType
     [currentDirection]="$any(filter).direction || 'ASC'"
     [striped]="true"
     (sortChange)="onSort($event)"
-    (rowClick)="editItem($event.id)"
-  ></devkit-table>`;
+    (rowClick)="editItem($event.id)"${customTemplatesAttr}
+  ></devkit-table>${templatesHtml}`;
     }
     const routerOutletHtml = formType === 'dialog' ? '\n  <!-- Outlet para carregar o Dialog Handler -->\n  <router-outlet></router-outlet>' : '';
     return `<div class="flex flex-col space-y-4 text-foreground">
@@ -57,11 +69,16 @@ function angularListTsTemplate(name, properties, listType = 'table', formType =
     const filterConfig = properties
         .filter((p) => p.type !== 'relationship')
         .map((p) => {
+        const type = p.type;
         let typeStr = 'text';
-        if (p.type === 'boolean')
+        if (type === 'boolean')
             typeStr = 'boolean';
-        if (p.type === 'datepicker')
+        if (type === 'datepicker' || type === 'date' || type === 'datetime')
             typeStr = 'datepicker';
+        if (type === 'enum' && p.enumOptions) {
+            const options = p.enumOptions.map((o) => ({ label: o, value: o }));
+            return `    { key: '${p.name}', label: '${p.label}', type: 'select', options: ${JSON.stringify(options)} }`;
+        }
         return `    { key: '${p.name}', label: '${p.label}', type: '${typeStr}' }`;
     })
         .concat(singularRelationships.map((relationship) => {
@@ -149,7 +166,7 @@ function angularListTsTemplate(name, properties, listType = 'table', formType =
     }).join('\n');
     return `import { ChangeDetectorRef, Component, OnInit, OnDestroy, inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { BaseListPage, RelationshipLookup } from '@devstroupe/devkit-angular';
+import { BaseListPage, RelationshipLookup, RealtimeService } from '@devstroupe/devkit-angular';
 import { ITableColumn } from '@devstroupe/ui/table/table.component';
 ${importComponent}
 import { DevkitFilterComponent, FilterItemConfig } from '@devstroupe/ui/filter/filter.component';
@@ -157,6 +174,7 @@ import { DevkitButtonComponent } from '@devstroupe/ui/button/button.component';
 ${routeImports}
 ${relationshipServiceImports}
 import { ${pascalName}Service } from '../../../services/${name}.service';
+import { takeUntil } from 'rxjs/operators';
 
 @Component({
   selector: 'app-${name}-list',
@@ -170,6 +188,7 @@ export class ${pascalName}ListComponent extends BaseListPage<any> implements OnI
   private _router = inject(Router);
   private _route = inject(ActivatedRoute);
   private _changeDetector = inject(ChangeDetectorRef);
+  private _realtime = inject(RealtimeService);
 ${relationshipInjections}
 
 ${relationshipState}
@@ -177,6 +196,9 @@ ${relationshipState}
   ngOnInit(): void {
     this.initBaseListPage(this._router, this._route, this._changeDetector);
 ${relationshipLoadCalls}
+    this._realtime.onEntityChanged('${name}')
+      .pipe(takeUntil(this.unsubscribeAll$))
+      .subscribe(() => this.loadItems());
   }
 
   ngOnDestroy(): void {

package/dist/templates/nest/crud.templates.d.ts

@@ -1,9 +1,23 @@
 import { IDevkitEntityProperty } from '@devstroupe/devkit-core';
 export declare function nestDomainEntityTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean): string;
 export declare function nestRepositoryPortTemplate(name: string): string;
-export declare function nestOrmEntityTemplate(name: string, properties: IDevkitEntityProperty[], tableName: string, isTenantScoped: boolean): string;
+export declare function nestOrmEntityTemplate(name: string, properties: IDevkitEntityProperty[], tableName: string, isTenantScoped: boolean, indexes?: Array<{
+    columns: string[];
+    unique?: boolean;
+    name?: string;
+}>, persistence?: {
+    deletion?: 'soft-delete' | 'hard-delete';
+    mode?: 'append-only' | 'standard';
+}, automaticFields?: {
+    timestamps?: boolean;
+    blamers?: boolean;
+    optimisticLocking?: boolean;
+}): string;
 export declare function nestRepositoryAdapterTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean): string;
 export declare function nestDtoTemplate(name: string, properties: IDevkitEntityProperty[]): string;
 export declare function nestServiceTemplate(name: string): string;
-export declare function nestControllerTemplate(name: string): string;
+export declare function nestControllerTemplate(name: string, persistence?: {
+    deletion?: 'soft-delete' | 'hard-delete';
+    mode?: 'append-only' | 'standard';
+}): string;
 export declare function nestModuleTemplate(name: string): string;

package/dist/templates/nest/crud.templates.js

@@ -24,7 +24,16 @@ function nestDomainEntityTemplate(name, properties, isTenantScoped) {
             }
             return `  ${relation.foreignKey}!: number;\n  ${relation.relationName}?: any;`;
         }
-        const typeStr = p.type === 'number' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        let typeStr = 'string';
+        if (p.type === 'number' || p.type === 'decimal' || p.type === 'currency') {
+            typeStr = 'number';
+        }
+        else if (p.type === 'boolean') {
+            typeStr = 'boolean';
+        }
+        else if (p.type === 'enum' && p.enumOptions) {
+            typeStr = p.enumOptions.map(o => `'${o}'`).join(' | ');
+        }
         return `  ${p.name}!: ${typeStr};`;
     })
         .join('\n');
@@ -49,7 +58,7 @@ export interface I${pascalName}Repository {
 }
 `;
 }
-function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped) {
+function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, indexes, persistence, automaticFields) {
     const pascalName = (0, names_1.kebabToPascal)(name);
     const relationships = (0, relationships_1.getRelationships)(properties);
     const typeormImports = ['Entity', 'PrimaryGeneratedColumn', 'Column'];
@@ -65,6 +74,14 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped) {
         typeormImports.push('JoinColumn');
     if (relationships.some((relation) => relation.kind === 'many-to-many' && relation.owner))
         typeormImports.push('JoinTable');
+    if (indexes && indexes.length > 0)
+        typeormImports.push('Index');
+    if (persistence?.deletion === 'soft-delete')
+        typeormImports.push('DeleteDateColumn');
+    if (automaticFields?.timestamps)
+        typeormImports.push('CreateDateColumn', 'UpdateDateColumn');
+    if (automaticFields?.optimisticLocking)
+        typeormImports.push('VersionColumn');
     const relImports = [...new Set(relationships.map((relation) => relation.target))]
         .map((targetKebab) => {
         const targetPascal = (0, names_1.kebabToPascal)(targetKebab);
@@ -98,21 +115,80 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped) {
             const joinColumn = relation.owner ? `\n  @JoinColumn({ name: '${relation.foreignKey}', referencedColumnName: '${relation.valueField}' })` : '';
             return `  ${fkDecorator}\n  ${relation.foreignKey}!: number;\n\n  @${decorator}(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''}, ${options})${joinColumn}\n  ${relation.relationName}?: ${targetPascal}OrmEntity;`;
         }
-        const decorator = p.required ? '@Column()' : '@Column({ nullable: true })';
-        const typeStr = p.type === 'number' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        let decorator = p.required ? '@Column()' : '@Column({ nullable: true })';
+        let typeStr = 'string';
+        const type = p.type;
+        if (type === 'number' || type === 'decimal' || type === 'currency' || type === 'integer') {
+            typeStr = 'number';
+            if (type === 'decimal' || type === 'currency') {
+                const precision = p.precision !== undefined ? p.precision : 12;
+                const scale = p.scale !== undefined ? p.scale : 2;
+                decorator = `@Column({ type: 'decimal', precision: ${precision}, scale: ${scale}${p.required ? '' : ', nullable: true'} })`;
+            }
+            else if (type === 'integer') {
+                decorator = p.required ? `@Column({ type: 'int' })` : `@Column({ type: 'int', nullable: true })`;
+            }
+        }
+        else if (type === 'bigint') {
+            typeStr = 'string';
+            decorator = p.required ? `@Column({ type: 'bigint' })` : `@Column({ type: 'bigint', nullable: true })`;
+        }
+        else if (type === 'boolean') {
+            typeStr = 'boolean';
+        }
+        else if (type === 'datepicker' || type === 'datetime') {
+            typeStr = 'Date';
+            decorator = p.required ? `@Column({ type: 'datetime' })` : `@Column({ type: 'datetime', nullable: true })`;
+        }
+        else if (type === 'date') {
+            typeStr = 'Date';
+            decorator = p.required ? `@Column({ type: 'date' })` : `@Column({ type: 'date', nullable: true })`;
+        }
+        else if (type === 'text') {
+            decorator = `@Column({ type: 'text'${p.required ? '' : ', nullable: true'} })`;
+        }
+        else if (type === 'json') {
+            typeStr = 'any';
+            decorator = p.required ? `@Column({ type: 'json' })` : `@Column({ type: 'json', nullable: true })`;
+        }
+        else if (type === 'enum' && p.enumOptions) {
+            typeStr = p.enumOptions.map(o => `'${o}'`).join(' | ');
+            decorator = `@Column({ type: 'enum', enum: ${JSON.stringify(p.enumOptions)}${p.required ? '' : ', nullable: true'} })`;
+        }
         return `  ${decorator}\n  ${p.name}!: ${typeStr};`;
     })
         .join('\n\n');
     const tenantField = isTenantScoped ? '\n\n  @Column()\n  tenantId!: string;' : '';
     const relImportsStr = relImports ? `\n${relImports}` : '';
+    const isSoftDelete = persistence?.deletion === 'soft-delete';
+    const softDeleteField = isSoftDelete ? '\n\n  @DeleteDateColumn({ name: \'deleted_at\', nullable: true })\n  deletedAt?: Date;' : '';
+    let autoFieldsStr = '';
+    if (automaticFields?.timestamps) {
+        autoFieldsStr += '\n\n  @CreateDateColumn({ name: \'created_at\' })\n  createdAt!: Date;\n\n  @UpdateDateColumn({ name: \'updated_at\' })\n  updatedAt!: Date;';
+    }
+    if (automaticFields?.blamers) {
+        autoFieldsStr += '\n\n  @Column({ name: \'created_by_user_id\', nullable: true })\n  createdByUserId?: number;\n\n  @Column({ name: \'updated_by_user_id\', nullable: true })\n  updatedByUserId?: number;';
+    }
+    if (automaticFields?.optimisticLocking) {
+        autoFieldsStr += '\n\n  @VersionColumn({ default: 1 })\n  version!: number;';
+    }
+    const indexDecorators = indexes && indexes.length > 0
+        ? indexes.map(idx => {
+            const nameOption = idx.name ? `name: '${idx.name}'` : '';
+            const uniqueOption = idx.unique ? `unique: true` : '';
+            const options = [nameOption, uniqueOption].filter(Boolean).join(', ');
+            const optionsStr = options ? `, { ${options} }` : '';
+            return `@Index(${JSON.stringify(idx.columns)}${optionsStr})`;
+        }).join('\n') + '\n'
+        : '';
     return `import { ${typeormImports.join(', ')} } from 'typeorm';${relImportsStr}
 
-@Entity('${tableName}')
+${indexDecorators}@Entity('${tableName}')
 export class ${pascalName}OrmEntity {
   @PrimaryGeneratedColumn()
   id!: number;
 
-${propsCode}${tenantField}
+${propsCode}${tenantField}${softDeleteField}${autoFieldsStr}
 }
 `;
 }
@@ -208,7 +284,7 @@ export class ${pascalName}RepositoryAdapter extends BaseRepository<${pascalName}
     const paginated = await this.paginate(qb, filter, {
       allowedFilters: [${allowedProperties.map(property => `'${property}'`).join(', ')}],
       allowedSorts: [${allowedProperties.map(property => `'${property}'`).join(', ')}],
-      searchableFields: [${properties.filter(p => p.type === 'string').map(p => `'${p.name}'`).join(', ') || "'id'"}],
+      searchableFields: [${properties.filter(p => p.type === 'string' || p.type === 'text').map(p => `'${p.name}'`).join(', ') || "'id'"}],
     });
 
     return {
@@ -244,14 +320,87 @@ function nestDtoTemplate(name, properties) {
         .map((p) => {
         const relationship = p.type === 'relationship' ? (0, relationships_1.getRelationships)([p])[0] : undefined;
         const isArray = relationship?.kind === 'many-to-many';
-        const apiProperty = `@ApiProperty({ example: ${isArray ? '[1, 2]' : p.type === 'number' || p.type === 'relationship' ? '1' : p.type === 'boolean' ? 'true' : "'value'"}, description: '${p.label}'${isArray ? ', isArray: true' : ''} })`;
+        const type = p.type;
+        const isNumber = type === 'number' || type === 'decimal' || type === 'currency' || type === 'integer' || type === 'relationship';
+        const isEnum = type === 'enum' && p.enumOptions;
+        const exampleVal = isArray
+            ? '[1, 2]'
+            : isNumber
+                ? '1'
+                : type === 'boolean'
+                    ? 'true'
+                    : isEnum
+                        ? `'${p.enumOptions[0]}'`
+                        : "'value'";
+        const enumAttr = isEnum ? `, enum: ${JSON.stringify(p.enumOptions)}` : '';
+        const apiProperty = `@ApiProperty({ example: ${exampleVal}, description: '${p.label}'${isArray ? ', isArray: true' : ''}${enumAttr} })`;
+        const validators = [];
+        if (p.required) {
+            validators.push('@IsNotEmpty()');
+        }
+        else {
+            validators.push('@IsOptional()');
+        }
+        if (isArray) {
+            validators.push('@IsArray()');
+        }
+        else if (type === 'relationship') {
+            validators.push('@IsNumber()');
+        }
+        else if (type === 'number' || type === 'decimal' || type === 'currency') {
+            validators.push('@IsNumber()');
+        }
+        else if (type === 'integer') {
+            validators.push('@IsInt()');
+        }
+        else if (type === 'bigint') {
+            validators.push('@IsString()');
+        }
+        else if (type === 'boolean') {
+            validators.push('@IsBoolean()');
+        }
+        else if (type === 'datepicker' || type === 'datetime' || type === 'date') {
+            validators.push('@IsDateString()');
+        }
+        else if (type === 'json') {
+            validators.push('@IsObject()');
+        }
+        else if (type === 'email') {
+            validators.push('@IsEmail()');
+        }
+        else if (isEnum) {
+            validators.push(`@IsIn(${JSON.stringify(p.enumOptions)})`);
+        }
+        else {
+            validators.push('@IsString()');
+        }
         const suffix = p.required ? '!' : '?';
-        const typeStr = isArray ? 'number[]' : p.type === 'number' || p.type === 'relationship' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        let typeStr = 'string';
+        if (isArray) {
+            typeStr = 'number[]';
+        }
+        else if (isNumber) {
+            typeStr = 'number';
+        }
+        else if (type === 'boolean') {
+            typeStr = 'boolean';
+        }
+        else if (type === 'datepicker' || type === 'datetime' || type === 'date') {
+            typeStr = 'string'; // ISO Date strings no DTO
+        }
+        else if (type === 'json') {
+            typeStr = 'any';
+        }
+        else if (isEnum) {
+            typeStr = p.enumOptions.map(o => `'${o}'`).join(' | ');
+        }
         const propertyName = relationship?.kind === 'many-to-many' ? relationship.relationName : p.name;
-        return `  ${apiProperty}\n  ${propertyName}${suffix}: ${typeStr};`;
+        const valStr = validators.join('\n  ');
+        return `  ${apiProperty}\n  ${valStr}\n  ${propertyName}${suffix}: ${typeStr};`;
     })
         .join('\n\n');
     return `import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsOptional, IsString, IsNumber, IsBoolean, IsDateString, IsObject, IsArray, IsInt, IsEmail, IsIn } from 'class-validator';
 
 export class Create${pascalName}Dto {
 ${createProps}
@@ -316,10 +465,23 @@ export class ${pascalName}Service {
 }
 `;
 }
-function nestControllerTemplate(name) {
+function nestControllerTemplate(name, persistence) {
     const pascalName = (0, names_1.kebabToPascal)(name);
     const camelName = (0, names_1.kebabToCamel)(name);
-    return `import { Controller } from '@nestjs/common';
+    const isAppendOnly = persistence?.mode === 'append-only';
+    const appendOnlyImports = isAppendOnly ? ', Put, Delete, MethodNotAllowedException' : '';
+    const appendOnlyMethods = isAppendOnly
+        ? `\n\n  @Put(':id')
+  override async update(): Promise<never> {
+    throw new MethodNotAllowedException('Updates not allowed for append-only entities.');
+  }
+
+  @Delete(':id')
+  override async delete(): Promise<never> {
+    throw new MethodNotAllowedException('Deletions not allowed for append-only entities.');
+  }`
+        : '';
+    return `import { Controller${appendOnlyImports} } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { BaseCrudController } from '@devstroupe/devkit-nest';
 import { ${pascalName}Service } from '../../service/${name}.service';
@@ -331,7 +493,7 @@ import { Filter${pascalName}Dto } from './${name}.dto';
 export class ${pascalName}Controller extends BaseCrudController<${pascalName}, Filter${pascalName}Dto> {
   constructor(private readonly ${camelName}Service: ${pascalName}Service) {
     super(${camelName}Service);
-  }
+  }${appendOnlyMethods}
 }
 `;
 }

package/dist/templates/nest/migration.template.js

@@ -5,12 +5,25 @@ exports.nestDataSourceTemplate = nestDataSourceTemplate;
 const names_1 = require("../shared/names");
 const relationships_1 = require("../shared/relationships");
 function columnType(property) {
-    if (property.type === 'number' || property.type === 'relationship')
+    const type = property.type;
+    if (type === 'number' || type === 'relationship' || type === 'integer')
         return 'int';
-    if (property.type === 'boolean')
+    if (type === 'bigint')
+        return 'bigint';
+    if (type === 'boolean')
         return 'boolean';
-    if (property.type === 'datepicker')
+    if (type === 'datepicker' || type === 'datetime')
         return 'datetime';
+    if (type === 'date')
+        return 'date';
+    if (type === 'decimal' || type === 'currency')
+        return 'decimal';
+    if (type === 'text')
+        return 'text';
+    if (type === 'enum')
+        return 'enum';
+    if (type === 'json')
+        return 'json';
     return 'varchar';
 }
 function columnDefault(property) {
@@ -23,6 +36,10 @@ function columnDefault(property) {
     return `, default: ${JSON.stringify(`'${String(property.default).replace(/'/g, "''")}'`)}`;
 }
 function targetTable(target, entities) {
+    if (target === 'user')
+        return 'users';
+    if (target === 'role')
+        return 'roles';
     const entity = entities.find((candidate) => candidate.name === target);
     return entity?.tableName ?? `${target}s`;
 }
@@ -30,9 +47,36 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
     const className = `Create${(0, names_1.kebabToPascal)(entity.name)}${timestamp}`;
     const tableName = entity.tableName ?? `${entity.name}s`;
     const relationships = (0, relationships_1.getRelationships)(properties);
+    const isSoftDelete = entity.persistence?.deletion === 'soft-delete';
     const scalarColumns = properties
         .filter((property) => property.type !== 'relationship')
-        .map((property) => `        { name: '${property.name}', type: '${columnType(property)}', isNullable: ${!property.required}${columnDefault(property)} }`);
+        .map((property) => {
+        let extraStr = '';
+        if (property.type === 'decimal' || property.type === 'currency') {
+            const precision = property.precision !== undefined ? property.precision : 12;
+            const scale = property.scale !== undefined ? property.scale : 2;
+            extraStr = `, precision: ${precision}, scale: ${scale}`;
+        }
+        else if (property.type === 'enum' && property.enumOptions) {
+            extraStr = `, enum: ${JSON.stringify(property.enumOptions)}`;
+        }
+        return `        { name: '${property.name}', type: '${columnType(property)}'${extraStr}, isNullable: ${!property.required}${columnDefault(property)} }`;
+    });
+    if (isSoftDelete) {
+        scalarColumns.push(`        { name: 'deleted_at', type: 'datetime', isNullable: true }`);
+    }
+    const autoFields = entity.automaticFields;
+    if (autoFields?.timestamps) {
+        scalarColumns.push(`        { name: 'created_at', type: 'datetime', default: 'CURRENT_TIMESTAMP' }`);
+        scalarColumns.push(`        { name: 'updated_at', type: 'datetime', default: 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' }`);
+    }
+    if (autoFields?.blamers) {
+        scalarColumns.push(`        { name: 'created_by_user_id', type: 'int', isNullable: true }`);
+        scalarColumns.push(`        { name: 'updated_by_user_id', type: 'int', isNullable: true }`);
+    }
+    if (autoFields?.optimisticLocking) {
+        scalarColumns.push(`        { name: 'version', type: 'int', default: 1 }`);
+    }
     const relationColumns = relationships
         .filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind))
         .map((relationship) => `        { name: '${relationship.foreignKey}', type: 'int', isNullable: ${!relationship.property.required}, isUnique: ${relationship.kind === 'one-to-one'} }`);
@@ -80,7 +124,37 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
     }), true);`,
         };
     });
-    return `import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm';
+    const indexes = entity.indexes;
+    const checks = entity.checks;
+    const tableIndexes = indexes && indexes.length > 0
+        ? indexes.map((idx) => {
+            const idxName = idx.name ?? `IDX_${tableName}_${idx.columns.join('_')}`;
+            return `    await queryRunner.createIndex('${tableName}', new TableIndex({
+      name: '${idxName}',
+      columnNames: ${JSON.stringify(idx.columns)},
+      isUnique: ${Boolean(idx.unique)}
+    }));`;
+        }).join('\n')
+        : '';
+    const dropIndexes = indexes && indexes.length > 0
+        ? indexes.map((idx) => {
+            const idxName = idx.name ?? `IDX_${tableName}_${idx.columns.join('_')}`;
+            return `    await queryRunner.dropIndex('${tableName}', '${idxName}');`;
+        }).join('\n')
+        : '';
+    const checkConstraints = checks && checks.length > 0
+        ? checks.map((chk, idx) => {
+            const checkName = `CHK_${tableName}_${idx}`;
+            return `    await queryRunner.query('ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${checkName}\` CHECK (${chk.replace(/'/g, "\\'")})');`;
+        }).join('\n')
+        : '';
+    const dropChecks = checks && checks.length > 0
+        ? checks.map((chk, idx) => {
+            const checkName = `CHK_${tableName}_${idx}`;
+            return `    await queryRunner.query('ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${checkName}\`');`;
+        }).join('\n')
+        : '';
+    return `import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm';
 
 export class ${className} implements MigrationInterface {
   name = '${className}';
@@ -96,12 +170,14 @@ ${foreignKeys ? `
     await queryRunner.createForeignKeys('${tableName}', [
 ${foreignKeys}
     ]);` : ''}
+${tableIndexes ? `\n${tableIndexes}` : ''}
+${checkConstraints ? `\n${checkConstraints}` : ''}
 ${junctions.map((junction) => `
 ${junction.up}`).join('\n')}
   }
 
   async down(queryRunner: QueryRunner): Promise<void> {
-${junctions.slice().reverse().map((junction) => `    await queryRunner.dropTable('${junction.tableName}', true);`).join('\n')}${junctions.length > 0 ? '\n' : ''}    await queryRunner.dropTable('${tableName}', true);
+${dropChecks ? `${dropChecks}\n` : ''}${dropIndexes ? `${dropIndexes}\n` : ''}${junctions.slice().reverse().map((junction) => `    await queryRunner.dropTable('${junction.tableName}', true);`).join('\n')}${junctions.length > 0 ? '\n' : ''}    await queryRunner.dropTable('${tableName}', true);
   }
 }
 `;

package/dist/templates/shared/relationships.js

@@ -17,17 +17,19 @@ function normalizeRelationship(property) {
         throw new Error(`Relationship property "${property.name}" must define relation.target.`);
     }
     const config = property.relation;
+    const rawTarget = config.target;
+    const target = rawTarget.startsWith('$') ? rawTarget.slice(1) : rawTarget;
     const kind = config.kind ?? 'many-to-one';
     const collection = isCollectionRelationship(kind);
     const relationName = config.relationName
-        ?? (collection ? property.name : config.target);
+        ?? (collection ? property.name : target);
     const control = config.control
         ?? (kind === 'one-to-many' ? 'table' : kind === 'many-to-many' ? 'multi-select' : 'select');
     const foreignKey = config.foreignKey
         ?? (isSingularRelationship(kind) ? property.name : undefined);
     return {
         property,
-        target: config.target,
+        target,
         kind,
         control,
         displayField: config.displayField ?? 'name',
@@ -61,7 +63,8 @@ function validateRelationships(entities) {
             if (property.type !== 'relationship')
                 continue;
             const relationship = normalizeRelationship(property);
-            if (!entityNames.has(relationship.target)) {
+            const targetIsNative = ['user', 'role'].includes(relationship.target);
+            if (!entityNames.has(relationship.target) && !targetIsNative) {
                 throw new Error(`Entity "${entity.name}" relationship "${property.name}" targets unknown entity "${relationship.target}".`);
             }
             if (isSingularRelationship(relationship.kind) && relationship.foreignKey === relationship.relationName) {
@@ -76,7 +79,7 @@ function validateRelationships(entities) {
             if (relationship.kind === 'one-to-many' && !relationship.foreignKey) {
                 throw new Error(`Entity "${entity.name}" one-to-many relationship "${property.name}" must define relation.foreignKey.`);
             }
-            if (relationship.kind === 'one-to-many') {
+            if (relationship.kind === 'one-to-many' && !targetIsNative) {
                 const target = entities.find((candidate) => candidate.name === relationship.target);
                 const targetHasForeignKey = target?.properties.some((candidate) => candidate.name === relationship.foreignKey
                     || (candidate.type === 'relationship'

package/dist/templates/ui/components/index.d.ts

@@ -8,3 +8,4 @@ export * from './simple-list.template';
 export * from './dialog.template';
 export * from './badge.template';
 export * from './avatar.template';
+export * from './textarea.template';

package/dist/templates/ui/components/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./simple-list.template"), exports);
 __exportStar(require("./dialog.template"), exports);
 __exportStar(require("./badge.template"), exports);
 __exportStar(require("./avatar.template"), exports);
+__exportStar(require("./textarea.template"), exports);

package/dist/templates/ui/components/input.template.js

@@ -25,6 +25,7 @@ export class DevkitInputComponent implements ControlValueAccessor {
   @Input() label = '';
   @Input() placeholder = '';
   @Input() type = 'text';
+  @Input() prefix = '';
   @Input() required = false;
   @Input() disabled = false;
 
@@ -60,15 +61,22 @@ export class DevkitInputComponent implements ControlValueAccessor {
   <label *ngIf="label" class="text-xs font-semibold text-muted-foreground">
     {{ label }}<span *ngIf="required" class="text-destructive ml-0.5">*</span>
   </label>
-  <input
-    hlmInput
-    [type]="type"
-    [value]="value"
-    [placeholder]="placeholder"
-    [disabled]="disabled"
-    (input)="onInput($event)"
-    (blur)="onTouched()"
-  />
+  <div class="relative flex items-center w-full">
+    <span *ngIf="prefix" class="absolute left-3 text-sm text-muted-foreground select-none pointer-events-none">
+      {{ prefix }}
+    </span>
+    <input
+      hlmInput
+      [type]="type"
+      [value]="value"
+      [placeholder]="placeholder"
+      [disabled]="disabled"
+      (input)="onInput($event)"
+      (blur)="onTouched()"
+      [class.pl-9]="prefix"
+      class="w-full"
+    />
+  </div>
 </div>
 `
     };

package/dist/templates/ui/components/textarea.template.d.ts

@@ -0,0 +1,4 @@
+export declare function devkitTextareaTemplate(): {
+    ts: string;
+    html: string;
+};