@devstroupe/devkit-cli 1.1.16 → 1.2.0-beta.1

package/dist/generation/backend-generator.integration.test.js

@@ -0,0 +1,232 @@
+"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_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const typescript_1 = __importDefault(require("typescript"));
+const index_1 = require("../index");
+const linter_rules_1 = require("../rules/linter-rules");
+const repositoryRoot = node_path_1.default.resolve(__dirname, '../../../..');
+const nestTemplate = node_path_1.default.join(repositoryRoot, 'boilerplates', 'nest-template');
+const entities = [
+    { name: 'account', properties: [], crud: { generateFrontend: false } },
+    { name: 'product', module: 'catalog', properties: [], crud: { generateFrontend: false } },
+    {
+        name: 'category', module: 'catalog', crud: { generateFrontend: false }, properties: [{
+                name: 'parentProductId', label: 'Parent product', type: 'relationship', required: false,
+                relation: { target: 'product', foreignKey: 'parentProductId', kind: 'many-to-one' },
+            }],
+    },
+    {
+        name: 'tag', module: 'catalog', crud: { generateFrontend: false }, properties: [{
+                name: 'products', label: 'Products', type: 'relationship', required: false,
+                relation: { target: 'product', kind: 'many-to-many', control: 'multi-select' },
+            }],
+    },
+    {
+        name: 'stock', module: 'inventory', crud: { generateFrontend: false }, properties: [{
+                name: 'productId', label: 'Product', type: 'relationship', required: true,
+                relation: { target: 'product', foreignKey: 'productId', kind: 'many-to-one' },
+            }],
+    },
+];
+function writeConfig(root, backendType) {
+    node_fs_1.default.writeFileSync(node_path_1.default.join(root, 'devstroupe.config.ts'), `module.exports = ${JSON.stringify({
+        projectName: 'fixture', backendType, backendPath: './backend', frontendPath: './frontend',
+        multiTenant: { enabled: true }, entities,
+    }, null, 2)};\n`);
+}
+function runGenerator(root) {
+    const previous = process.cwd();
+    process.chdir(root);
+    try {
+        index_1.program.parse(['node', 'devstroupe', 'generate', 'crud', 'all']);
+    }
+    finally {
+        process.chdir(previous);
+    }
+}
+function applyModuleMove(root, entityName, moduleName) {
+    const previous = process.cwd();
+    process.chdir(root);
+    try {
+        index_1.program.parse(['node', 'devstroupe', 'entity:set-module', entityName, moduleName, '--apply']);
+    }
+    finally {
+        process.chdir(previous);
+    }
+}
+function assertCompiles(projectRoot) {
+    const nodeModules = node_path_1.default.join(projectRoot, 'node_modules');
+    if (!node_fs_1.default.existsSync(nodeModules))
+        node_fs_1.default.symlinkSync(node_path_1.default.join(nestTemplate, 'node_modules'), nodeModules, 'dir');
+    const configPath = node_path_1.default.join(projectRoot, 'tsconfig.json');
+    const loaded = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    const parsed = typescript_1.default.parseJsonConfigFileContent(loaded.config, typescript_1.default.sys, projectRoot, {
+        noEmit: true, incremental: false,
+    }, configPath);
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(typescript_1.default.createProgram(parsed.fileNames, parsed.options));
+    strict_1.default.equal(diagnostics.length, 0, typescript_1.default.formatDiagnosticsWithColorAndContext(diagnostics, {
+        getCurrentDirectory: () => projectRoot,
+        getCanonicalFileName: (fileName) => fileName,
+        getNewLine: () => '\n',
+    }));
+}
+(0, node_test_1.default)('monolith generation groups entities and remains idempotent', () => {
+    const root = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'devkit-monolith-'));
+    const backend = node_path_1.default.join(root, 'backend');
+    node_fs_1.default.cpSync(nestTemplate, backend, {
+        recursive: true,
+        filter: (source) => !source.includes(`${node_path_1.default.sep}node_modules`) && !source.includes(`${node_path_1.default.sep}dist`),
+    });
+    writeConfig(root, 'monolith');
+    runGenerator(root);
+    runGenerator(root);
+    const catalogModule = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/catalog/catalog.module.ts'), 'utf8');
+    const appModule = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/app.module.ts'), 'utf8');
+    const productController = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/catalog/product/api/product.controller.ts'), 'utf8');
+    const categoryEntity = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/catalog/category/infrastructure/persistence/typeorm/category.orm-entity.ts'), 'utf8');
+    const categoryRepository = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/catalog/category/infrastructure/persistence/typeorm/category.repository.ts'), 'utf8');
+    const tagRepository = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/catalog/tag/infrastructure/persistence/typeorm/tag.repository.ts'), 'utf8');
+    const stockEntity = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'src/modules/inventory/stock/infrastructure/persistence/typeorm/stock.orm-entity.ts'), 'utf8');
+    strict_1.default.match(catalogModule, /ProductOrmEntity/);
+    strict_1.default.match(catalogModule, /CategoryOrmEntity/);
+    strict_1.default.match(catalogModule, /TagOrmEntity/);
+    strict_1.default.match(productController, /@UseGuards\(JwtAuthGuard\)/);
+    strict_1.default.match(productController, /@ApiBearerAuth\(\)/);
+    strict_1.default.match(categoryEntity, /ProductOrmEntity/);
+    strict_1.default.match(categoryEntity, /@ManyToOne/);
+    strict_1.default.match(categoryRepository, /allowedFilters = \["parentProductId"\]/);
+    strict_1.default.match(categoryRepository, /allowedSorts = \["parentProductId"\]/);
+    strict_1.default.match(tagRepository, /allowedFilters = \[\]/);
+    strict_1.default.equal((appModule.match(/CatalogModule/g) ?? []).length, 2); // import + @Module entry
+    strict_1.default.doesNotMatch(stockEntity, /ProductOrmEntity/);
+    strict_1.default.match(stockEntity, /productId/);
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'src/modules/core/core.module.ts')));
+    strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(backend, 'src/modules/product/product.module.ts')));
+    assertCompiles(backend);
+    strict_1.default.equal((0, linter_rules_1.runLinter)(root, {
+        backendPath: './backend', frontendPath: './frontend', multiTenant: { enabled: true }, entities,
+    }).violations.filter(({ severity }) => severity === 'error').length, 0);
+    applyModuleMove(root, 'account', 'accounts');
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'src/modules/accounts/account')));
+    strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(backend, 'src/modules/core/account')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(root, 'devstroupe.config.ts.devstroupe-backup')));
+    strict_1.default.match(node_fs_1.default.readFileSync(node_path_1.default.join(root, 'devstroupe.config.ts'), 'utf8'), /"name": "account",\n\s+module: 'accounts',/);
+    assertCompiles(backend);
+});
+(0, node_test_1.default)('microservice generation creates one HTTP application, database and gateway route per module', () => {
+    const root = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'devkit-microservices-'));
+    writeConfig(root, 'microservices');
+    runGenerator(root);
+    runGenerator(root);
+    const backend = node_path_1.default.join(root, 'backend');
+    const compose = node_fs_1.default.readFileSync(node_path_1.default.join(root, 'docker-compose.yml'), 'utf8');
+    const initSql = node_fs_1.default.readFileSync(node_path_1.default.join(root, 'db-init/init.sql'), 'utf8');
+    const gatewayCatalog = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'api-gateway/src/modules/catalog/catalog.module.ts'), 'utf8');
+    const gatewayCatalogController = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'api-gateway/src/modules/catalog/catalog.gateway.controller.ts'), 'utf8');
+    const gatewayAppModule = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'api-gateway/src/app.module.ts'), 'utf8');
+    const catalogRoot = node_path_1.default.join(backend, 'apps/catalog-service');
+    const catalogAppModule = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'src/app.module.ts'), 'utf8');
+    const catalogMain = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'src/main.ts'), 'utf8');
+    const catalogDataSource = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'src/database/data-source.ts'), 'utf8');
+    const catalogProductHttp = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'src/modules/catalog/product/api/product.controller.ts'), 'utf8');
+    const catalogCategoryEntity = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'src/modules/catalog/category/infrastructure/persistence/typeorm/category.orm-entity.ts'), 'utf8');
+    const catalogDockerIgnore = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, '.dockerignore'), 'utf8');
+    const catalogPackage = node_fs_1.default.readFileSync(node_path_1.default.join(catalogRoot, 'package.json'), 'utf8');
+    const platformPackage = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'packages/platform/package.json'), 'utf8');
+    const catalogMigrations = node_fs_1.default.readdirSync(node_path_1.default.join(catalogRoot, 'src/database/migrations'));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'apps/catalog-service/src/modules/catalog/catalog.module.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'apps/core-service/src/modules/core/core.module.ts')));
+    strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(backend, 'apps/product-service')));
+    strict_1.default.match(gatewayCatalog, /ModuleHttpProxy/);
+    strict_1.default.match(gatewayCatalog, /CatalogGatewayController/);
+    strict_1.default.match(gatewayCatalogController, /@Controller\('catalog'\)/);
+    strict_1.default.match(gatewayCatalogController, /authenticateGatewayRequest/);
+    strict_1.default.match(gatewayCatalogController, /CATALOG_SERVICE_HOST/);
+    strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(backend, 'api-gateway/src/modules/catalog/product')));
+    strict_1.default.doesNotMatch(gatewayAppModule, /TypeOrmModule|UserModule|AuthModule|RoleModule/);
+    strict_1.default.doesNotMatch(gatewayAppModule, /,TokenVerificationModule/);
+    strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(backend, 'api-gateway/src/database')));
+    strict_1.default.match(compose, /devstroupe_catalog/);
+    strict_1.default.doesNotMatch(compose, /DB_NAME: devstroupe_gateway_identity/);
+    strict_1.default.doesNotMatch(initSql, /devstroupe_gateway_identity/);
+    strict_1.default.doesNotMatch(compose, /devstroupe_product/);
+    strict_1.default.doesNotMatch(compose, /"3001:3001"/);
+    strict_1.default.match(compose, /expose:\n\s+- "3001"/);
+    strict_1.default.equal((compose.match(/^  catalog-service:/gm) ?? []).length, 1);
+    strict_1.default.match(catalogAppModule, /migrationsRun: true/);
+    strict_1.default.match(catalogAppModule, /TokenVerificationModule/);
+    strict_1.default.match(catalogAppModule, /ExecutionContextInterceptor/);
+    strict_1.default.match(catalogMain, /NestFactory\.create\(AppModule\)/);
+    strict_1.default.doesNotMatch(catalogMain, /Transport\.TCP|createMicroservice/);
+    strict_1.default.match(catalogProductHttp, /@Controller\('catalog\/product'\)/);
+    strict_1.default.match(catalogProductHttp, /extends BaseCrudController/);
+    strict_1.default.match(catalogCategoryEntity, /ProductOrmEntity/);
+    strict_1.default.match(catalogDataSource, /infrastructure\/persistence\/typeorm/);
+    strict_1.default.ok(catalogMigrations.some((file) => file.endsWith('-create-product.ts')));
+    strict_1.default.ok(catalogMigrations.some((file) => file.endsWith('-create-category.ts')));
+    strict_1.default.ok(!catalogMigrations.some((file) => file.endsWith('-create-users.ts')));
+    strict_1.default.ok(!catalogMigrations.some((file) => file.endsWith('-create-roles.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(catalogRoot, 'src/platform/security/token-verification.module.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'api-gateway/src/platform/security/token-verification.module.ts')));
+    const coreRoot = node_path_1.default.join(backend, 'apps/core-service');
+    const coreAppModule = node_fs_1.default.readFileSync(node_path_1.default.join(coreRoot, 'src/app.module.ts'), 'utf8');
+    const coreModule = node_fs_1.default.readFileSync(node_path_1.default.join(coreRoot, 'src/modules/core/core.module.ts'), 'utf8');
+    strict_1.default.match(coreAppModule, /SecurityModule/);
+    strict_1.default.match(coreModule, /AuthModule/);
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(coreRoot, 'src/modules/user/user.module.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(coreRoot, 'src/modules/role/role.module.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(coreRoot, 'src/modules/auth/auth.module.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(coreRoot, 'src/database/migrations/1600000000000-create-roles.ts')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(coreRoot, 'src/database/migrations/1700000000000-create-users.ts')));
+    strict_1.default.match(catalogDockerIgnore, /^node_modules$/m);
+    strict_1.default.match(catalogDockerIgnore, /^local_packages\/\*\/node_modules$/m);
+    strict_1.default.match(platformPackage, /"name": "@fixture\/platform"/);
+    strict_1.default.match(catalogPackage, /"@fixture\/platform": "file:local_packages\/project-platform"/);
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(catalogRoot, 'local_packages/project-platform/src/integrations/index.js')));
+    strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(backend, 'packages/platform/src/observability/README.md')));
+    strict_1.default.equal(node_fs_1.default.readdirSync(node_path_1.default.join(backend, 'packages/platform/src'), { recursive: true })
+        .some((entry) => String(entry).endsWith('.orm-entity.ts')), false);
+    assertCompiles(node_path_1.default.join(backend, 'api-gateway'));
+    for (const service of ['catalog-service', 'core-service', 'inventory-service']) {
+        assertCompiles(node_path_1.default.join(backend, 'apps', service));
+    }
+    strict_1.default.equal((0, linter_rules_1.runLinter)(root, {
+        backendType: 'microservices', backendPath: './backend', frontendPath: './frontend',
+        multiTenant: { enabled: true }, entities,
+    }).violations.filter(({ severity }) => severity === 'error').length, 0);
+});
+(0, node_test_1.default)('local package copies preserve runtime dependencies in Docker builds', () => {
+    const root = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'devkit-local-packages-'));
+    const backend = node_path_1.default.join(root, 'backend');
+    node_fs_1.default.mkdirSync(backend, { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(backend, 'package.json'), JSON.stringify({
+        dependencies: {
+            '@devstroupe/devkit-core': 'workspace:*',
+            '@devstroupe/devkit-nest': 'workspace:*',
+        },
+    }));
+    node_fs_1.default.writeFileSync(node_path_1.default.join(backend, 'Dockerfile'), [
+        'FROM node:20-alpine',
+        'COPY package*.json ./',
+        'RUN npm install && rm -rf local_packages/*/node_modules',
+        'RUN npm install --only=production && rm -rf local_packages/*/node_modules',
+    ].join('\n'));
+    node_fs_1.default.writeFileSync(node_path_1.default.join(backend, 'tsconfig.json'), JSON.stringify({ compilerOptions: {} }));
+    (0, index_1.patchLocalDependencies)(backend, null, node_path_1.default.join(repositoryRoot, 'packages/devkit-cli/dist/boilerplates'));
+    (0, index_1.patchLocalDependencies)(backend, null, node_path_1.default.join(repositoryRoot, 'packages/devkit-cli/dist/boilerplates'));
+    const localNestPackage = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'local_packages/devkit-nest/package.json'), 'utf8'));
+    const dockerfile = node_fs_1.default.readFileSync(node_path_1.default.join(backend, 'Dockerfile'), 'utf8');
+    strict_1.default.equal(localNestPackage.dependencies['@devstroupe/devkit-core'], 'file:../devkit-core');
+    strict_1.default.ok(localNestPackage.dependencies['@aws-sdk/client-s3']);
+    strict_1.default.ok(localNestPackage.peerDependencies['@nestjs/core']);
+    strict_1.default.match(dockerfile, /COPY local_packages\/ \.\/local_packages\//);
+    strict_1.default.equal((dockerfile.match(/COPY local_packages\/ \.\/local_packages\//g) ?? []).length, 1);
+    strict_1.default.doesNotMatch(dockerfile, /rm -rf local_packages/);
+});

package/dist/generation/backend-layout.d.ts

@@ -0,0 +1,15 @@
+import { IDevkitEntityConfig, IDevkitEntityModuleGroup, IDevkitEntityProperty } from '@devstroupe/devkit-core';
+export interface BackendModuleGroup extends IDevkitEntityModuleGroup {
+    serviceName: string;
+    databaseName: string;
+    port: number;
+}
+export declare function buildBackendModuleGroups(entities: readonly IDevkitEntityConfig[], firstPort?: number): BackendModuleGroup[];
+export declare function moduleForEntity(entity: IDevkitEntityConfig, entities: readonly IDevkitEntityConfig[]): BackendModuleGroup;
+/**
+ * Cross-module relationships are persisted as identifiers only. This keeps a
+ * monolith module extractable and prevents cross-database TypeORM metadata.
+ */
+export declare function persistencePropertiesForEntity(entity: IDevkitEntityConfig, entities: readonly IDevkitEntityConfig[]): IDevkitEntityProperty[];
+export declare function crossModuleRelationships(entity: IDevkitEntityConfig, entities: readonly IDevkitEntityConfig[]): string[];
+export declare function validateModuleRelationships(entities: readonly IDevkitEntityConfig[]): void;

package/dist/generation/backend-layout.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBackendModuleGroups = buildBackendModuleGroups;
+exports.moduleForEntity = moduleForEntity;
+exports.persistencePropertiesForEntity = persistencePropertiesForEntity;
+exports.crossModuleRelationships = crossModuleRelationships;
+exports.validateModuleRelationships = validateModuleRelationships;
+const devkit_core_1 = require("@devstroupe/devkit-core");
+const relationships_1 = require("../templates/shared/relationships");
+function buildBackendModuleGroups(entities, firstPort = 3001) {
+    const configured = (0, devkit_core_1.groupEntitiesByModule)(entities);
+    const core = configured.find((group) => group.name === 'core') ?? { name: 'core', entities: [] };
+    const groups = [core, ...configured.filter((group) => group.name !== 'core')];
+    return groups.map((group, index) => ({
+        ...group,
+        serviceName: `${group.name}-service`,
+        databaseName: `devstroupe_${group.name.replace(/-/g, '_')}`,
+        port: firstPort + index,
+    }));
+}
+function moduleForEntity(entity, entities) {
+    const moduleName = (0, devkit_core_1.resolveEntityModule)(entity);
+    const group = buildBackendModuleGroups(entities).find((candidate) => candidate.name === moduleName);
+    if (!group)
+        throw new Error(`Functional module "${moduleName}" was not found.`);
+    return group;
+}
+/**
+ * Cross-module relationships are persisted as identifiers only. This keeps a
+ * monolith module extractable and prevents cross-database TypeORM metadata.
+ */
+function persistencePropertiesForEntity(entity, entities) {
+    const ownerModule = (0, devkit_core_1.resolveEntityModule)(entity);
+    return entity.properties.flatMap((property) => {
+        if (property.type !== 'relationship')
+            return [property];
+        const relationship = (0, relationships_1.normalizeRelationship)(property);
+        const target = entities.find((candidate) => candidate.name === relationship.target);
+        if (!target || (0, devkit_core_1.resolveEntityModule)(target) === ownerModule)
+            return [property];
+        if (!relationship.foreignKey)
+            return [];
+        return [{
+                name: relationship.foreignKey,
+                label: property.label,
+                type: 'number',
+                required: property.required,
+                index: true,
+            }];
+    });
+}
+function crossModuleRelationships(entity, entities) {
+    const ownerModule = (0, devkit_core_1.resolveEntityModule)(entity);
+    return entity.properties
+        .filter((property) => property.type === 'relationship')
+        .map(relationships_1.normalizeRelationship)
+        .filter((relationship) => {
+        const target = entities.find((candidate) => candidate.name === relationship.target);
+        return target && (0, devkit_core_1.resolveEntityModule)(target) !== ownerModule;
+    })
+        .map((relationship) => relationship.property.name);
+}
+function validateModuleRelationships(entities) {
+    for (const entity of entities) {
+        const ownerModule = (0, devkit_core_1.resolveEntityModule)(entity);
+        for (const property of entity.properties.filter((candidate) => candidate.type === 'relationship')) {
+            const relationship = (0, relationships_1.normalizeRelationship)(property);
+            const target = entities.find((candidate) => candidate.name === relationship.target);
+            if (!target || (0, devkit_core_1.resolveEntityModule)(target) === ownerModule)
+                continue;
+            if (relationship.kind === 'one-to-many' || relationship.kind === 'many-to-many') {
+                throw new Error(`Cross-module ${relationship.kind} "${entity.name}.${property.name}" is not a TypeORM relation. `
+                    + 'Model the association as an explicit owned entity/CRUD with external IDs.');
+            }
+        }
+    }
+}

package/dist/generation/backend-layout.test.d.ts

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

package/dist/generation/backend-layout.test.js

@@ -0,0 +1,48 @@
+"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 backend_layout_1 = require("./backend-layout");
+const entities = [
+    { name: 'product', module: 'catalog', properties: [] },
+    { name: 'category', module: 'catalog', properties: [] },
+    {
+        name: 'stock', module: 'inventory', properties: [{
+                name: 'productId', label: 'Product', type: 'relationship', required: true,
+                relation: { target: 'product', kind: 'many-to-one', foreignKey: 'productId' },
+            }],
+    },
+    { name: 'user', properties: [] },
+];
+(0, node_test_1.default)('backend groups expose stable service, database and port metadata', () => {
+    strict_1.default.deepEqual((0, backend_layout_1.buildBackendModuleGroups)(entities).map(({ name, serviceName, databaseName, port, entities: members }) => ({
+        name, serviceName, databaseName, port, members: members.map(({ name: entityName }) => entityName),
+    })), [
+        { name: 'core', serviceName: 'core-service', databaseName: 'devstroupe_core', port: 3001, members: ['user'] },
+        { name: 'catalog', serviceName: 'catalog-service', databaseName: 'devstroupe_catalog', port: 3002, members: ['category', 'product'] },
+        { name: 'inventory', serviceName: 'inventory-service', databaseName: 'devstroupe_inventory', port: 3003, members: ['stock'] },
+    ]);
+});
+(0, node_test_1.default)('cross-module TypeORM relationships become scalar identifiers', () => {
+    const stock = entities.find(({ name }) => name === 'stock');
+    strict_1.default.deepEqual((0, backend_layout_1.persistencePropertiesForEntity)(stock, entities), [{
+            name: 'productId', label: 'Product', type: 'number', required: true, index: true,
+        }]);
+});
+(0, node_test_1.default)('same-module many-to-many stays local while cross-module collections require explicit ownership', () => {
+    const local = [
+        { name: 'product', module: 'catalog', properties: [] },
+        { name: 'tag', module: 'catalog', properties: [{
+                    name: 'products', label: 'Products', type: 'relationship',
+                    relation: { target: 'product', kind: 'many-to-many', control: 'multi-select' },
+                }] },
+    ];
+    strict_1.default.doesNotThrow(() => (0, backend_layout_1.validateModuleRelationships)(local));
+    strict_1.default.throws(() => (0, backend_layout_1.validateModuleRelationships)([
+        local[0],
+        { ...local[1], module: 'taxonomy' },
+    ]), /explicit owned entity\/CRUD with external IDs/);
+});

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 #!/usr/bin/env node
-export {};
+import { Command } from 'commander';
+declare const program: Command;
+export declare function patchLocalDependencies(backendDest: string | null, frontendDest: string | null, boilerplatesDir: string): void;
+export { program };