@devstroupe/devkit-cli 1.0.0

package/dist/templates/nest/microservice.templates.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestGatewayControllerTemplate = nestGatewayControllerTemplate;
+exports.nestGatewayModuleTemplate = nestGatewayModuleTemplate;
+exports.nestMsControllerTemplate = nestMsControllerTemplate;
+exports.nestMsModuleTemplate = nestMsModuleTemplate;
+const names_1 = require("../shared/names");
+function nestGatewayControllerTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const serviceToken = `${name.toUpperCase()}_SERVICE`;
+    return `import { Controller, Get, Post, Put, Delete, Body, Param, Query, Inject, UseGuards, Headers } from '@nestjs/common';
+import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
+import { ClientProxy } from '@nestjs/microservices';
+import { firstValueFrom } from 'rxjs';
+import { Create${pascalName}Dto, Update${pascalName}Dto, Filter${pascalName}Dto } from './${name}.dto';
+import { JwtAuthGuard } from '../../../auth/jwt-auth.guard';
+
+@Controller('${name}')
+@ApiTags('${name}')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+export class ${pascalName}GatewayController {
+  constructor(
+    @Inject('${serviceToken}') private readonly client: ClientProxy
+  ) {}
+
+  @Post()
+  async create(
+    @Body() dto: Create${pascalName}Dto,
+    @Headers('x-tenant-id') tenantId: string
+  ) {
+    return firstValueFrom(this.client.send({ cmd: 'create_${name}' }, { data: dto, tenantId }));
+  }
+
+  @Put(':id')
+  async update(
+    @Param('id') id: string,
+    @Body() dto: Update${pascalName}Dto,
+    @Headers('x-tenant-id') tenantId: string
+  ) {
+    return firstValueFrom(this.client.send({ cmd: 'update_${name}' }, { id: Number(id), dto, tenantId }));
+  }
+
+  @Get()
+  async findMany(
+    @Query() filter: Filter${pascalName}Dto,
+    @Headers('x-tenant-id') tenantId: string
+  ) {
+    return firstValueFrom(this.client.send({ cmd: 'find_many_${name}' }, { filter, tenantId }));
+  }
+
+  @Get(':id')
+  async findOne(
+    @Param('id') id: string,
+    @Headers('x-tenant-id') tenantId: string
+  ) {
+    return firstValueFrom(this.client.send({ cmd: 'find_one_${name}' }, { id: Number(id), tenantId }));
+  }
+
+  @Delete(':id')
+  async delete(
+    @Param('id') id: string,
+    @Headers('x-tenant-id') tenantId: string
+  ) {
+    return firstValueFrom(this.client.send({ cmd: 'delete_${name}' }, { id: Number(id), tenantId }));
+  }
+}
+`;
+}
+function nestGatewayModuleTemplate(name, defaultPort) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const serviceToken = `${name.toUpperCase()}_SERVICE`;
+    return `import { Module } from '@nestjs/common';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+import { ${pascalName}GatewayController } from './infra/http/${name}.controller';
+
+@Module({
+  imports: [
+    ClientsModule.register([
+      {
+        name: '${serviceToken}',
+        transport: Transport.TCP,
+        options: {
+          host: process.env.${name.toUpperCase()}_SERVICE_HOST || 'localhost',
+          port: Number(process.env.${name.toUpperCase()}_SERVICE_PORT) || ${defaultPort},
+        },
+      },
+    ]),
+  ],
+  controllers: [${pascalName}GatewayController],
+})
+export class ${pascalName}GatewayModule {}
+`;
+}
+function nestMsControllerTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const camelName = (0, names_1.kebabToCamel)(name);
+    return `import { Controller } from '@nestjs/common';
+import { MessagePattern } from '@nestjs/microservices';
+import { ${pascalName}Service } from '../../service/${name}.service';
+import { Create${pascalName}Dto, Update${pascalName}Dto, Filter${pascalName}Dto } from './${name}.dto';
+
+@Controller()
+export class ${pascalName}MsController {
+  constructor(private readonly ${camelName}Service: ${pascalName}Service) {}
+
+  @MessagePattern({ cmd: 'create_${name}' })
+  async create(payload: { data: Create${pascalName}Dto, tenantId: string }) {
+    return this.${camelName}Service.create(payload.data);
+  }
+
+  @MessagePattern({ cmd: 'update_${name}' })
+  async update(payload: { id: number, dto: Update${pascalName}Dto, tenantId: string }) {
+    return this.${camelName}Service.update(payload.id, payload.dto);
+  }
+
+  @MessagePattern({ cmd: 'find_one_${name}' })
+  async findOne(payload: { id: number, tenantId: string }) {
+    return this.${camelName}Service.findOne(payload.id);
+  }
+
+  @MessagePattern({ cmd: 'find_many_${name}' })
+  async findMany(payload: { filter: Filter${pascalName}Dto, tenantId: string }) {
+    return this.${camelName}Service.findMany(payload.filter);
+  }
+
+  @MessagePattern({ cmd: 'delete_${name}' })
+  async delete(payload: { id: number, tenantId: string }) {
+    return this.${camelName}Service.delete(payload.id);
+  }
+}
+`;
+}
+function nestMsModuleTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    return `import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ${pascalName}OrmEntity } from './infra/database/${name}.orm-entity';
+import { ${pascalName}RepositoryAdapter } from './infra/database/${name}.repository';
+import { ${pascalName}Service } from './service/${name}.service';
+import { ${pascalName}MsController } from './infra/http/${name}.ms.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([${pascalName}OrmEntity])],
+  controllers: [${pascalName}MsController],
+  providers: [
+    ${pascalName}Service,
+    {
+      provide: 'I${pascalName}Repository',
+      useClass: ${pascalName}RepositoryAdapter,
+    },
+  ],
+  exports: [${pascalName}Service],
+})
+export class ${pascalName}Module {}
+`;
+}

package/dist/templates/nest/migration.template.d.ts

@@ -0,0 +1,3 @@
+import { IDevkitEntityConfig, IDevkitEntityProperty } from '@devstroupe/devkit-core';
+export declare function nestMigrationTemplate(entity: IDevkitEntityConfig, entities: IDevkitEntityConfig[], timestamp: number, properties?: IDevkitEntityProperty[]): string;
+export declare function nestDataSourceTemplate(): string;

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestMigrationTemplate = nestMigrationTemplate;
+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')
+        return 'int';
+    if (property.type === 'boolean')
+        return 'boolean';
+    if (property.type === 'datepicker')
+        return 'datetime';
+    return 'varchar';
+}
+function columnDefault(property) {
+    if (property.default === undefined)
+        return '';
+    if (typeof property.default === 'boolean')
+        return `, default: ${property.default ? "'1'" : "'0'"}`;
+    if (typeof property.default === 'number')
+        return `, default: '${property.default}'`;
+    return `, default: ${JSON.stringify(`'${String(property.default).replace(/'/g, "''")}'`)}`;
+}
+function targetTable(target, entities) {
+    const entity = entities.find((candidate) => candidate.name === target);
+    return entity?.tableName ?? `${target}s`;
+}
+function nestMigrationTemplate(entity, entities, timestamp, properties = entity.properties) {
+    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 scalarColumns = properties
+        .filter((property) => property.type !== 'relationship')
+        .map((property) => `        { name: '${property.name}', type: '${columnType(property)}', isNullable: ${!property.required}${columnDefault(property)} }`);
+    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'} }`);
+    const foreignKeys = relationships
+        .filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind))
+        .map((relationship) => `      new TableForeignKey({
+        name: 'FK_${tableName}_${relationship.foreignKey}',
+        columnNames: ['${relationship.foreignKey}'],
+        referencedTableName: '${targetTable(relationship.target, entities)}',
+        referencedColumnNames: ['${relationship.valueField}'],
+        onDelete: '${relationship.onDelete}'
+      })`)
+        .join(',\n');
+    const junctions = relationships
+        .filter((relationship) => relationship.kind === 'many-to-many' && relationship.owner)
+        .map((relationship) => {
+        const referencedTable = targetTable(relationship.target, entities);
+        const junctionTable = relationship.joinTableName ?? `${entity.name}_${relationship.target}`;
+        const sourceColumn = `${entity.name}_id`;
+        const targetColumn = `${relationship.target}_id`;
+        return {
+            tableName: junctionTable,
+            up: `    await queryRunner.createTable(new Table({
+      name: '${junctionTable}',
+      columns: [
+        { name: '${sourceColumn}', type: 'int', isPrimary: true },
+        { name: '${targetColumn}', type: 'int', isPrimary: true }
+      ],
+      foreignKeys: [
+        {
+          name: 'FK_${junctionTable}_${sourceColumn}',
+          columnNames: ['${sourceColumn}'],
+          referencedTableName: '${tableName}',
+          referencedColumnNames: ['id'],
+          onDelete: 'CASCADE'
+        },
+        {
+          name: 'FK_${junctionTable}_${targetColumn}',
+          columnNames: ['${targetColumn}'],
+          referencedTableName: '${referencedTable}',
+          referencedColumnNames: ['${relationship.valueField}'],
+          onDelete: 'CASCADE'
+        }
+      ]
+    }), true);`,
+        };
+    });
+    return `import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm';
+
+export class ${className} implements MigrationInterface {
+  name = '${className}';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(new Table({
+      name: '${tableName}',
+      columns: [
+        { name: 'id', type: 'int', isPrimary: true, isGenerated: true, generationStrategy: 'increment' }${scalarColumns.length + relationColumns.length > 0 ? ',\n' : ''}${[...scalarColumns, ...relationColumns].join(',\n')}
+      ]
+    }), true);
+${foreignKeys ? `
+    await queryRunner.createForeignKeys('${tableName}', [
+${foreignKeys}
+    ]);` : ''}
+${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);
+  }
+}
+`;
+}
+function nestDataSourceTemplate() {
+    return `import 'reflect-metadata';
+import 'dotenv/config';
+import { DataSource } from 'typeorm';
+import * as path from 'path';
+
+export default new DataSource({
+  type: 'mysql',
+  host: process.env.DB_HOST || 'localhost',
+  port: Number(process.env.DB_PORT) || 3306,
+  username: process.env.DB_USER || 'root',
+  password: process.env.DB_PASSWORD || 'root',
+  database: process.env.DB_NAME || 'devstroupe',
+  entities: [path.join(__dirname, '../modules/**/infra/database/*.orm-entity{.ts,.js}')],
+  migrations: [path.join(__dirname, './migrations/*{.ts,.js}')],
+  synchronize: false
+});
+`;
+}

package/dist/templates/relationship-templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/relationship-templates.test.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const typescript_1 = __importDefault(require("typescript"));
+const form_template_1 = require("./angular/form.template");
+const list_template_1 = require("./angular/list.template");
+const crud_templates_1 = require("./nest/crud.templates");
+const microservice_templates_1 = require("./nest/microservice.templates");
+const migration_template_1 = require("./nest/migration.template");
+const relationships_1 = require("./shared/relationships");
+const sort_entities_1 = require("../migrations/sort-entities");
+const select_template_1 = require("./ui/components/select.template");
+const entities = [
+    {
+        name: 'company',
+        label: 'Empresa',
+        tableName: 'companies',
+        properties: [
+            { name: 'name', type: 'string', required: true, label: 'Nome' },
+            {
+                name: 'cabins',
+                type: 'relationship',
+                label: 'Cabines',
+                relation: {
+                    target: 'cabin',
+                    kind: 'one-to-many',
+                    foreignKey: 'company_id',
+                    inverseSide: 'company',
+                    control: 'table',
+                    columns: ['name', 'code'],
+                },
+            },
+        ],
+    },
+    {
+        name: 'cabin',
+        label: 'Cabine',
+        tableName: 'cabins',
+        properties: [
+            { name: 'name', type: 'string', required: true, label: 'Nome' },
+            { name: 'code', type: 'string', label: 'Código' },
+            {
+                name: 'company_id',
+                type: 'relationship',
+                required: true,
+                label: 'Empresa',
+                relation: {
+                    target: 'company',
+                    kind: 'many-to-one',
+                    relationName: 'company',
+                    inverseSide: 'cabins',
+                    control: 'select',
+                },
+            },
+        ],
+    },
+];
+function assertValidTypeScript(source) {
+    const result = typescript_1.default.transpileModule(source, {
+        compilerOptions: { target: typescript_1.default.ScriptTarget.ES2022, experimentalDecorators: true },
+        reportDiagnostics: true,
+    });
+    const errors = (result.diagnostics ?? []).filter((diagnostic) => diagnostic.category === typescript_1.default.DiagnosticCategory.Error);
+    strict_1.default.deepEqual(errors.map((error) => error.messageText), []);
+}
+(0, node_test_1.default)('relationship config generates select and embedded dependent table', () => {
+    (0, relationships_1.validateRelationships)(entities);
+    const companyHtml = (0, form_template_1.angularFormHtmlTemplate)('company', entities[0].properties, entities);
+    const companyTs = (0, form_template_1.angularFormTsTemplate)('company', entities[0].properties, entities);
+    const cabinHtml = (0, form_template_1.angularFormHtmlTemplate)('cabin', entities[1].properties, entities);
+    const cabinTs = (0, form_template_1.angularFormTsTemplate)('cabin', entities[1].properties, entities);
+    const cabinListTs = (0, list_template_1.angularListTsTemplate)('cabin', entities[1].properties);
+    strict_1.default.match(companyHtml, /<devkit-table/);
+    strict_1.default.match(companyHtml, /previousCabinsPage/);
+    strict_1.default.match(companyHtml, /<app-cabin-form/);
+    strict_1.default.match(companyHtml, /\[initialValues\]="cabinsInitialValues"/);
+    strict_1.default.match(companyHtml, /\[hiddenFields\]="\['company_id'\]"/);
+    strict_1.default.match(companyTs, /filter: \{ .*company_id: this\.itemId \}/);
+    strict_1.default.match(cabinHtml, /formControlName="company_id"/);
+    strict_1.default.match(cabinHtml, /<devkit-select/);
+    strict_1.default.match(cabinListTs, /options: this\.companyIdLookup\.options/);
+    strict_1.default.match(cabinListTs, /pageSize: 20/);
+    strict_1.default.match(cabinListTs, /companyIdLookup\.setSearch\(search\)/);
+    strict_1.default.match(cabinTs, /new RelationshipLookup<any>/);
+    assertValidTypeScript(companyTs);
+    assertValidTypeScript(cabinTs);
+    assertValidTypeScript(cabinListTs);
+});
+(0, node_test_1.default)('relationship select exposes debounced remote search and incremental loading', () => {
+    const select = (0, select_template_1.devkitSelectTemplate)();
+    strict_1.default.match(select.ts, /searchChange = new EventEmitter<string>/);
+    strict_1.default.match(select.ts, /setTimeout\(\(\) => this\.searchChange\.emit/);
+    strict_1.default.match(select.html, /Carregar mais/);
+    strict_1.default.match(select.html, /loadMore\.emit\(\)/);
+    assertValidTypeScript(select.ts);
+});
+(0, node_test_1.default)('relationship config generates TypeORM joins and scoped repository filters', () => {
+    const companyOrm = (0, crud_templates_1.nestOrmEntityTemplate)('company', entities[0].properties, 'companies', false);
+    const cabinOrm = (0, crud_templates_1.nestOrmEntityTemplate)('cabin', entities[1].properties, 'cabins', false);
+    const companyRepository = (0, crud_templates_1.nestRepositoryAdapterTemplate)('company', entities[0].properties, false);
+    const cabinRepository = (0, crud_templates_1.nestRepositoryAdapterTemplate)('cabin', entities[1].properties, false);
+    strict_1.default.match(companyOrm, /@OneToMany\(\(\) => CabinOrmEntity, target => target\.company\)/);
+    strict_1.default.match(cabinOrm, /@ManyToOne\(\(\) => CompanyOrmEntity, target => target\.cabins/);
+    strict_1.default.match(cabinOrm, /@JoinColumn\(\{ name: 'company_id', referencedColumnName: 'id' \}\)/);
+    strict_1.default.match(cabinRepository, /qb\.leftJoinAndSelect\(`\$\{alias\}\.company`, 'company'\)/);
+    strict_1.default.match(cabinRepository, /allowedFilters: \['name', 'code', 'company_id'\]/);
+    strict_1.default.doesNotMatch(companyRepository, /leftJoinAndSelect/);
+    assertValidTypeScript(companyOrm);
+    assertValidTypeScript(cabinOrm);
+    assertValidTypeScript(companyRepository);
+    assertValidTypeScript(cabinRepository);
+});
+(0, node_test_1.default)('many-to-many generates a multiple selector and owning join table', () => {
+    const manyToManyEntities = [
+        { name: 'role', properties: [{ name: 'name', type: 'string', label: 'Nome' }] },
+        {
+            name: 'user',
+            properties: [{
+                    name: 'roles',
+                    type: 'relationship',
+                    label: 'Perfis',
+                    relation: { target: 'role', kind: 'many-to-many', control: 'multi-select' },
+                }],
+        },
+    ];
+    (0, relationships_1.validateRelationships)(manyToManyEntities);
+    const html = (0, form_template_1.angularFormHtmlTemplate)('user', manyToManyEntities[1].properties, manyToManyEntities);
+    const orm = (0, crud_templates_1.nestOrmEntityTemplate)('user', manyToManyEntities[1].properties, 'users', false);
+    const repository = (0, crud_templates_1.nestRepositoryAdapterTemplate)('user', manyToManyEntities[1].properties, false);
+    const migration = (0, migration_template_1.nestMigrationTemplate)({ ...manyToManyEntities[1], tableName: 'users' }, manyToManyEntities, 2000);
+    strict_1.default.match(html, /\[multiple\]="true"/);
+    strict_1.default.match(orm, /@ManyToMany\(\(\) => RoleOrmEntity\)/);
+    strict_1.default.match(orm, /@JoinTable\(\{/);
+    strict_1.default.match(orm, /name: 'user_role'/);
+    strict_1.default.match(repository, /orm\.roles = domain\.roles!\.map/);
+    strict_1.default.match(repository, /ormRepository\.preload/);
+    strict_1.default.match(migration, /name: 'user_role'/);
+    strict_1.default.match(migration, /name: 'user_id', type: 'int', isPrimary: true/);
+    assertValidTypeScript(migration);
+});
+(0, node_test_1.default)('relationship migrations create foreign keys and owning junction tables', () => {
+    const companyMigration = (0, migration_template_1.nestMigrationTemplate)(entities[0], entities, 1000);
+    const cabinMigration = (0, migration_template_1.nestMigrationTemplate)(entities[1], entities, 1001);
+    const dataSource = (0, migration_template_1.nestDataSourceTemplate)();
+    strict_1.default.match(companyMigration, /name: 'companies'/);
+    strict_1.default.doesNotMatch(companyMigration, /FK_companies_cabins/);
+    strict_1.default.match(cabinMigration, /name: 'company_id', type: 'int'/);
+    strict_1.default.match(cabinMigration, /referencedTableName: 'companies'/);
+    strict_1.default.match(cabinMigration, /onDelete: 'CASCADE'/);
+    strict_1.default.match(dataSource, /migrations: \[path\.join/);
+    strict_1.default.match(dataSource, /synchronize: false/);
+    assertValidTypeScript(companyMigration);
+    assertValidTypeScript(cabinMigration);
+    assertValidTypeScript(dataSource);
+    const ordered = (0, sort_entities_1.sortEntitiesForMigrations)([entities[1], entities[0]]);
+    strict_1.default.deepEqual(ordered.map((entity) => entity.name), ['company', 'cabin']);
+});
+(0, node_test_1.default)('invalid relationship targets fail before files are generated', () => {
+    strict_1.default.throws(() => (0, relationships_1.validateRelationships)([{
+            name: 'cabin',
+            properties: [{
+                    name: 'company_id',
+                    type: 'relationship',
+                    label: 'Empresa',
+                    relation: { target: 'missing-company' },
+                }],
+        }]), /targets unknown entity/);
+});
+(0, node_test_1.default)('kebab-case entities generate valid controller identifiers', () => {
+    const controller = (0, crud_templates_1.nestControllerTemplate)('item-pedido');
+    const msController = (0, microservice_templates_1.nestMsControllerTemplate)('item-pedido');
+    strict_1.default.match(controller, /itemPedidoService: ItemPedidoService/);
+    strict_1.default.doesNotMatch(controller, /item-pedidoService/);
+    strict_1.default.match(msController, /this\.itemPedidoService\.findMany/);
+    assertValidTypeScript(controller);
+    assertValidTypeScript(msController);
+});

package/dist/templates/shared/names.d.ts

@@ -0,0 +1,3 @@
+export declare function capitalize(s: string): string;
+export declare function kebabToCamel(s: string): string;
+export declare function kebabToPascal(s: string): string;

package/dist/templates/shared/names.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = capitalize;
+exports.kebabToCamel = kebabToCamel;
+exports.kebabToPascal = kebabToPascal;
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function kebabToCamel(s) {
+    return s.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+}
+function kebabToPascal(s) {
+    return capitalize(kebabToCamel(s));
+}

package/dist/templates/shared/relationships.d.ts

@@ -0,0 +1,27 @@
+import { DevkitRelationshipControl, DevkitRelationshipKind, IDevkitEntityConfig, IDevkitEntityProperty, IDevkitRelationshipColumn } from '@devstroupe/devkit-core';
+export interface NormalizedRelationship {
+    property: IDevkitEntityProperty;
+    target: string;
+    kind: DevkitRelationshipKind;
+    control: DevkitRelationshipControl;
+    displayField: string;
+    valueField: string;
+    relationName: string;
+    foreignKey?: string;
+    inverseSide?: string;
+    owner: boolean;
+    embedded: boolean;
+    onDelete: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    columns: IDevkitRelationshipColumn[];
+    filters: Record<string, unknown>;
+    lookupMode: 'remote' | 'all';
+    pageSize: number;
+    minSearchLength: number;
+    joinTableName?: string;
+}
+export declare function isCollectionRelationship(kind: DevkitRelationshipKind): boolean;
+export declare function isSingularRelationship(kind: DevkitRelationshipKind): boolean;
+export declare function normalizeRelationship(property: IDevkitEntityProperty): NormalizedRelationship;
+export declare function getRelationships(properties: IDevkitEntityProperty[]): NormalizedRelationship[];
+export declare function getTargetEntity(relationship: NormalizedRelationship, entities: IDevkitEntityConfig[]): IDevkitEntityConfig | undefined;
+export declare function validateRelationships(entities: IDevkitEntityConfig[]): void;

package/dist/templates/shared/relationships.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCollectionRelationship = isCollectionRelationship;
+exports.isSingularRelationship = isSingularRelationship;
+exports.normalizeRelationship = normalizeRelationship;
+exports.getRelationships = getRelationships;
+exports.getTargetEntity = getTargetEntity;
+exports.validateRelationships = validateRelationships;
+function isCollectionRelationship(kind) {
+    return kind === 'one-to-many' || kind === 'many-to-many';
+}
+function isSingularRelationship(kind) {
+    return !isCollectionRelationship(kind);
+}
+function normalizeRelationship(property) {
+    if (property.type !== 'relationship' || !property.relation?.target) {
+        throw new Error(`Relationship property "${property.name}" must define relation.target.`);
+    }
+    const config = property.relation;
+    const kind = config.kind ?? 'many-to-one';
+    const collection = isCollectionRelationship(kind);
+    const relationName = config.relationName
+        ?? (collection ? property.name : config.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,
+        kind,
+        control,
+        displayField: config.displayField ?? 'name',
+        valueField: config.valueField ?? 'id',
+        relationName,
+        foreignKey,
+        inverseSide: config.inverseSide,
+        owner: config.owner ?? true,
+        embedded: config.embedded ?? kind === 'one-to-many',
+        onDelete: config.onDelete ?? (property.required ? 'CASCADE' : 'SET NULL'),
+        columns: (config.columns ?? []).map((column) => typeof column === 'string' ? { key: column } : column),
+        filters: config.filters ?? {},
+        lookupMode: config.lookup?.mode ?? 'remote',
+        pageSize: config.lookup?.pageSize ?? 20,
+        minSearchLength: config.lookup?.minSearchLength ?? 0,
+        joinTableName: config.joinTableName,
+    };
+}
+function getRelationships(properties) {
+    return properties
+        .filter((property) => property.type === 'relationship')
+        .map(normalizeRelationship);
+}
+function getTargetEntity(relationship, entities) {
+    return entities.find((entity) => entity.name === relationship.target);
+}
+function validateRelationships(entities) {
+    const entityNames = new Set(entities.map((entity) => entity.name));
+    for (const entity of entities) {
+        for (const property of entity.properties) {
+            if (property.type !== 'relationship')
+                continue;
+            const relationship = normalizeRelationship(property);
+            if (!entityNames.has(relationship.target)) {
+                throw new Error(`Entity "${entity.name}" relationship "${property.name}" targets unknown entity "${relationship.target}".`);
+            }
+            if (isSingularRelationship(relationship.kind) && relationship.foreignKey === relationship.relationName) {
+                throw new Error(`Entity "${entity.name}" relationship "${property.name}" must use different foreignKey and relationName values.`);
+            }
+            if (relationship.kind === 'one-to-one' && !relationship.owner) {
+                throw new Error(`Entity "${entity.name}" inverse one-to-one relationship "${property.name}" is not an owning form field. Declare it on the owning entity or model it as an embedded dependent.`);
+            }
+            if (relationship.kind === 'many-to-many' && !relationship.owner) {
+                throw new Error(`Entity "${entity.name}" many-to-many relationship "${property.name}" must be generated on the owning side.`);
+            }
+            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') {
+                const target = entities.find((candidate) => candidate.name === relationship.target);
+                const targetHasForeignKey = target?.properties.some((candidate) => candidate.name === relationship.foreignKey
+                    || (candidate.type === 'relationship'
+                        && normalizeRelationship(candidate).foreignKey === relationship.foreignKey));
+                if (!targetHasForeignKey) {
+                    throw new Error(`Entity "${entity.name}" relationship "${property.name}" expects foreign key "${relationship.foreignKey}" on "${relationship.target}".`);
+                }
+            }
+            if (isSingularRelationship(relationship.kind) && !['select'].includes(relationship.control)) {
+                throw new Error(`Entity "${entity.name}" singular relationship "${property.name}" must use control "select".`);
+            }
+            if (relationship.kind === 'many-to-many' && relationship.control !== 'multi-select') {
+                throw new Error(`Entity "${entity.name}" many-to-many relationship "${property.name}" must use control "multi-select".`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function devkitAvatarTemplate(): {
+    ts: string;
+};