@team-codeme/crud-forge 0.0.0-stage → 1.0.1

package/test/fixtures/performance/large.gdl

@@ -0,0 +1,199 @@
+@Audited
+entity Province {
+  string index
+  string provinceCode
+  string provinceName
+  bool isActive
+}
+
+@Audited
+entity Catalog01 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog02 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog03 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog04 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog05 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog06 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog07 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog08 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog09 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog10 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog11 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog12 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog13 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog14 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog15 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog16 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog17 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog18 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog19 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog20 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog21 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog22 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog23 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}
+
+@Audited
+entity Catalog24 {
+  string code
+  string name
+  int quantity
+  bool isActive
+}

package/test/fixtures/performance/small.gdl

@@ -0,0 +1,7 @@
+@Audited
+entity Province {
+  string index
+  string provinceCode
+  string provinceName
+  bool isActive
+}

package/test/fixtures/quality/custom.yml

@@ -0,0 +1,22 @@
+backend:
+  kind: custom
+input:
+  file: ./gdl/example.gdl
+  type: gdl
+fuse:
+  enabled: true
+  cleanLayout: true
+  includePrebuilt: false
+api:
+  microservice: catalog
+  baseUrl: /v1
+generate:
+  globals:
+    tests: true
+testing:
+  ci: true
+  fixtures:
+    Farmer:
+      referenceCode: AB12
+auth:
+  provider: none

package/test/fixtures/quality/go-duck.yml

@@ -0,0 +1,22 @@
+backend:
+  kind: go-duck
+input:
+  file: ./gdl/example.gdl
+  type: gdl
+fuse:
+  enabled: true
+  cleanLayout: true
+  includePrebuilt: false
+api:
+  microservice: reference-service
+  baseUrl: /api
+generate:
+  globals:
+    tests: true
+testing:
+  ci: true
+  fixtures:
+    Farmer:
+      referenceCode: AB12
+auth:
+  provider: none

package/test/fixtures/quality/jhipster.yml

@@ -0,0 +1,30 @@
+backend:
+  kind: jhipster
+input:
+  file: ./gdl/example.gdl
+  type: gdl
+fuse:
+  enabled: true
+  cleanLayout: true
+  includePrebuilt: false
+api:
+  microservice: registry
+  baseUrl: /api
+generate:
+  globals:
+    tests: true
+testing:
+  ci: true
+  fixtures:
+    Farmer:
+      referenceCode: AB12
+auth:
+  provider: keycloak
+  realm: test
+  clientId: test-client
+  serverUrl: http://127.0.0.1:9999
+  useMockAuth: false
+  provision:
+    enabled: false
+iam:
+  enabled: false

package/test/fixtures/quality/representative.gdl

@@ -0,0 +1,14 @@
+enum Status { ACTIVE, INACTIVE }
+entity Province {
+  string name required minlength(2)
+}
+entity Farmer {
+  string name required maxlength(30)
+  Status status required
+  bool active
+  date birthDate required
+  string referenceCode required pattern(^[A-Z]{2}[0-9]{2}$)
+}
+relationship ManyToOne {
+  Farmer{province} to Province{farmer}
+}

package/test/list-state.js

@@ -0,0 +1,138 @@
+// Behavioral tests of shared generated UI logic. Requires Node 24+, like the Fuse app.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { stripTypeScriptTypes } = require('node:module');
+const ejs = require('ejs');
+const rx = require('rxjs');
+
+function load(relative, exported, context = {}, preferences = {}, locals = {}) {
+  let source = ejs.render(fs.readFileSync(path.join(__dirname, '../src/templates/angular', relative), 'utf8'), { preferences, ...locals });
+  source = source.replace(/^import[\s\S]*?;\n/gm, '')
+    .replace(/@(Component|Injectable|Pipe)\([\s\S]*?\)\s*/g, '')
+    .replace(/@(ViewChild|Input|Output)\([^\n]*?\)\s*/g, '')
+    .replace(/^export /gm, '');
+  const module = { exports: {} };
+  vm.runInNewContext(stripTypeScriptTypes(source) + `\nmodule.exports = ${exported};`, { module, ...rx, ...context });
+  return module.exports;
+}
+
+async function main() {
+  const id = '11111111-2222-3333-4444-555555555555';
+  let calls = 0;
+  let lookup = () => rx.of({ id, firstName: ' First ', lastName: 'Last' });
+  const NameService = load('shared/base/audit-user-name.pipe.ts.ejs', 'AuditUserNameService', {
+    KeycloakAdminService: {}, inject: () => ({ getUserById: () => { ++calls; return lookup(); } }),
+  }, { fuse: { enabled: true }, auth: { provider: 'keycloak' } });
+  const names = new NameService();
+  assert.equal(await rx.firstValueFrom(names.resolve('Already Named')), 'Already Named');
+  assert.equal(await rx.firstValueFrom(names.resolve(null)), '');
+  assert.equal(calls, 0);
+  assert.equal(await rx.firstValueFrom(names.resolve(id)), 'First Last');
+  assert.equal(await rx.firstValueFrom(names.resolve(id)), 'First Last');
+  assert.equal(calls, 1, 'Repeated actors reuse a single lookup');
+  lookup = () => rx.of({ data: { user: { id, attributes: { given_name: ['First'], family_name: ['Last'] } } } });
+  assert.equal(await rx.firstValueFrom(new NameService().resolve(id)), 'First Last');
+  lookup = () => rx.throwError(() => new Error('Forbidden'));
+  assert.equal(await rx.firstValueFrom(new NameService().resolve(id)), id);
+  lookup = () => rx.of({ id: 'different-user', firstName: 'Wrong' });
+  assert.equal(await rx.firstValueFrom(new NameService().resolve(id)), id);
+  const NoAuthNames = load('shared/base/audit-user-name.pipe.ts.ejs', 'AuditUserNameService');
+  assert.equal(await rx.firstValueFrom(new NoAuthNames().resolve(id)), id);
+
+  const storage = new Map();
+  let observer;
+  const cleanup = [];
+  const Base = load('shared/base/base-list.component.ts.ejs', 'BaseListComponent', {
+    localStorage: { getItem: k => storage.get(k) ?? null, setItem: (k, v) => storage.set(k, v) },
+    ResizeObserver: class { constructor(callback) { observer = callback; } observe() {} disconnect() { cleanup.push('disconnected'); } },
+  });
+  const list = Object.create(Base.prototype);
+  Object.assign(list, {
+    entityNameKebab: 'book', viewMode: 'table', cdr: { markForCheck() {} },
+    viewDestroyRef: { onDestroy(callback) { cleanup.push(callback); } },
+    listViewport: { nativeElement: { getBoundingClientRect: () => ({ width: 1000 }) } },
+    allColumnPreferences: [{key:'state',alwaysVisible:true},{key:'title'},{key:'createdBy',defaultHidden:true}],
+  });
+  list.restoreColumnPreferences();
+  assert.deepEqual(Array.from(list.displayedColumns), ['state', 'title']);
+  list.toggleColumn('createdBy');
+  list.restoreColumnPreferences();
+  assert.ok(list.displayedColumns.includes('createdBy'));
+  list.resetColumnPreferences();
+  assert.ok(!list.displayedColumns.includes('createdBy'));
+  storage.set(list.columnPreferenceStorageKey, '[]');
+  list.restoreColumnPreferences();
+  assert.deepEqual(Array.from(list.displayedColumns), ['state'], 'Empty saved selections are distinct from no saved preference');
+  storage.set(list.columnPreferenceStorageKey, '{broken');
+  list.restoreColumnPreferences();
+  assert.deepEqual(Array.from(list.displayedColumns), ['state', 'title']);
+  list.restoreViewMode();
+  list.observeListWidth();
+  observer([{ contentRect: { width: 500 } }]);
+  assert.equal(list.viewMode, 'card');
+  assert.equal(storage.has(list.storageKeyViewMode), false);
+  observer([{ contentRect: { width: 900 } }]);
+  assert.equal(list.viewMode, 'table');
+  list.onViewModeChange('card');
+  assert.equal(storage.get(list.storageKeyViewMode), 'card');
+  observer([{ contentRect: { width: 1000 } }]);
+  assert.equal(list.viewMode, 'card');
+  cleanup[0]();
+  assert.equal(cleanup[1], 'disconnected');
+  const locals = {
+    entity: { name: 'Book', fields: [], relationships: [] }, relationships: [], iamAcl: false,
+    toCamelCase: value => value[0].toLowerCase() + value.slice(1),
+    toKebabCase: value => value.toLowerCase(),
+  };
+  const FormBase = load('shared/base/base-form.component.ts.ejs', 'BaseFormComponent');
+  const Form = load('entity/components/forms/form/_entity_-form.component.ts.ejs', 'BookFormComponent',
+    { BaseFormComponent: FormBase }, {}, locals);
+  const form = Object.create(Form.prototype);
+  let resetValue;
+  let pristine = 0, untouched = 0;
+  Object.assign(form, {
+    isInitialized: true, entity: {id: 10}, errorMessage: 'old error', dialogData: { defaults: { title: 'Default' } },
+    form: { markAsPristine: () => pristine++, markAsUntouched: () => untouched++ },
+    formService: { resetForm: (_, entity) => { resetValue = entity; } },
+  });
+  form.ngOnChanges({ entity: { currentValue: {id: 10, title: 'Edited'} } });
+  assert.equal(resetValue.id, 10);
+  form.ngOnChanges({ entity: { currentValue: null } });
+  assert.equal(resetValue.id, null);
+  assert.equal(resetValue.title, 'Default');
+  assert.equal(form.entity, null);
+  assert.equal(form.errorMessage, null);
+  assert.equal(pristine, 1);
+  assert.equal(untouched, 1);
+  form.ngOnChanges({ entity: { currentValue: undefined } });
+  assert.equal(resetValue.id, null);
+
+  const List = load('entity/components/presentation/list/_entity_-list.component.ts.ejs', 'BookListComponent',
+    { BaseListComponent: Base, takeUntilDestroyed: () => source => source }, {}, locals);
+  const host = Object.create(List.prototype);
+  const pending = new Map();
+  const mounts = [];
+  Object.assign(host, {
+    formRequestVersion: 0, formMode: 'sidebar', destroyRef: {}, formDrawer: { open() {}, close() {} },
+    cdr: { detectChanges: () => mounts.push(host.formVisible), markForCheck() {} },
+    bookService: { find: id => { const request = new rx.Subject(); pending.set(id, request); return request; } },
+  });
+  host.openEdit(1);
+  host.openFormDrawer();
+  pending.get(1).next({body: {id: 1, title: 'Stale'}});
+  assert.equal(host.selectedBook, null, 'Late edit response must not overwrite New');
+  assert.equal(host.drawerMode, 'new');
+  host.openEdit(1);
+  host.openEdit(2);
+  pending.get(2).next({body: {id: 2}});
+  pending.get(1).next({body: {id: 1}});
+  assert.equal(host.selectedBook.id, 2);
+  assert.deepEqual(mounts, [false, true, false, true], 'Every opening destroys before mounting');
+  host.closeFormDrawer();
+  assert.equal(host.selectedBook, null);
+  assert.equal(host.formVisible, false);
+  console.log('List state tests passed: audit names/cache/fallback, column defaults/preferences, responsive saved view, observer cleanup, reused form defaults, and stale edit responses.');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/micro-functions-layout.js

@@ -0,0 +1,95 @@
+const assert = require('assert/strict');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { generate, parseJdl } = require('../src');
+const defaults = require('../src/config/default-values');
+
+(async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'crudforge-micro-functions-'));
+  try {
+    const config = structuredClone(defaults);
+    config.output.directory = root;
+    config.fuse = { ...config.fuse, enabled: true, includePrebuilt: false,
+      starterPackPath: path.resolve(__dirname, '../fuse-starter-pack/fuse-v21.1') };
+    config.input.sources = [
+      { name: 'Identity', folder: 'identityAccessModule' },
+      { name: 'Reference', folder: 'referenceModule' },
+    ];
+    const parsed = parseJdl('enum State { ACTIVE, INACTIVE }\nentity Staff {\n name String\n state State\n}\nentity Province {\n name String\n}\nrelationship ManyToOne { Staff{province} to Province }\nrelationship OneToMany { Province{staff} to Staff }');
+    for (const entity of parsed.entities) {
+      for (const field of entity.fields) field.fieldTypeIsEnum = parsed.enums.some(en => en.name === field.fieldType);
+      const identity = entity.name === 'Staff';
+      entity.folderName = identity ? 'identityAccessModule' : 'referenceModule';
+      entity.sourceName = identity ? 'Identity' : 'Reference';
+      entity.microservice = identity ? 'identity-service' : 'reference-service';
+    }
+    await generate(parsed, config);
+    const apps = path.join(root, 'src/app/domains/admin/modules/apps');
+    const staff = path.join(apps, 'micro-functions/identityAccessModule/entities/staff');
+    const province = path.join(apps, 'micro-functions/referenceModule/entities/province');
+    assert(fs.existsSync(path.join(apps, 'micro-functions/referenceModule/enum')));
+    assert(!fs.existsSync(path.join(apps, 'enums')));
+    assert(fs.existsSync(path.join(staff, 'staff.model.ts')));
+    assert(fs.existsSync(path.join(province, 'province.model.ts')));
+    assert(!fs.existsSync(path.join(apps, 'identityAccessModule')));
+    assert(!fs.existsSync(path.join(apps, 'referenceModule')));
+    const routes = fs.readFileSync(path.join(root, 'src/app/domains/admin/routes.ts'), 'utf8');
+    assert(routes.includes('./modules/apps/micro-functions/identityAccessModule/entities/staff/staff.routes'));
+    assert(fs.readFileSync(path.join(staff, 'service/staff.service.ts'), 'utf8').includes('/services/identity-service/api/staffs'));
+    // Every relative TS import must resolve, including cross-service relationship imports.
+    function verify(dir) {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory()) verify(file);
+        else if (file.endsWith('.ts')) {
+          const content = fs.readFileSync(file, 'utf8');
+          for (const match of content.matchAll(/(?:from\s*|import\s*\()['"](\.[^'"]+)['"]/g)) {
+            const target = path.resolve(path.dirname(file), match[1]);
+            assert(fs.existsSync(target + '.ts') || fs.existsSync(path.join(target, 'index.ts')), `${file}: ${match[1]}`);
+          }
+        }
+      }
+    }
+    verify(staff);
+    verify(province);
+    assert(fs.readFileSync(path.join(staff, 'staff.model.ts'), 'utf8').includes('../../enum/state.model'));
+    // Separate schemas may define the same enum name with different values.
+    const cliConfig = structuredClone(config);
+    cliConfig.output.directory = path.join(root, 'cli-output');
+    cliConfig.input.sources = [
+      { name: 'Identity Access', folder: 'identity-access', file: path.join(root, 'identity.jdl'), microservice: 'identity-service' },
+      { name: 'Reference', folder: 'reference', file: path.join(root, 'reference.jdl'), microservice: 'reference-service' },
+      { name: 'Inventory', folder: 'inventory', file: path.join(root, 'inventory.jdl'), microservice: 'inventory-service' },
+    ];
+    fs.writeFileSync(cliConfig.input.sources[0].file, 'enum State { ACTIVE, INACTIVE }\nentity Staff {\n state State\n}');
+    fs.writeFileSync(cliConfig.input.sources[1].file, 'enum State { OPEN, CLOSED }\nentity Province {\n state State\n}');
+    fs.writeFileSync(cliConfig.input.sources[2].file, 'entity Product {\n name String\n}');
+    const configPath = path.join(root, 'config.yml');
+    fs.writeFileSync(configPath, require('yaml').stringify(cliConfig));
+    const result = require('child_process').spawnSync(process.execPath,
+      [path.resolve(__dirname, '../cli.js'), 'generate', '--preferences', configPath, '--yes'],
+      { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert(fs.readFileSync(path.join(cliConfig.output.directory, 'generator/README.md'), 'utf8')
+      .includes('Agents and developers should record generator issues'));
+    assert(fs.existsSync(path.join(cliConfig.output.directory, 'generator/issues/.gitkeep')));
+    const modules = path.join(cliConfig.output.directory, 'src/app/domains/admin/modules/apps/micro-functions');
+    assert(fs.statSync(path.join(modules, 'inventory/entities')).isDirectory());
+    assert(fs.statSync(path.join(modules, 'inventory/enum')).isDirectory());
+    assert.deepEqual(fs.readdirSync(path.join(modules, 'inventory/enum')), ['.gitkeep']);
+    const identityEnum = fs.readFileSync(path.join(modules, 'identity-access/enum/state.model.ts'), 'utf8');
+    const referenceEnum = fs.readFileSync(path.join(modules, 'reference/enum/state.model.ts'), 'utf8');
+    assert(identityEnum.includes('ACTIVE') && !identityEnum.includes('CLOSED'));
+    assert(referenceEnum.includes('CLOSED') && !referenceEnum.includes('ACTIVE'));
+    verify(path.join(modules, 'identity-access/entities'));
+    verify(path.join(modules, 'reference/entities'));
+    config.generate.enums = false;
+    config.dryRun = true;
+    config.output.directory = path.join(root, 'disabled-enums-preview');
+    const preview = await require('../src/generator/project-output').generateProject(parsed, config);
+    assert(preview.dryRunReport.newFiles.some(file => file.path.endsWith('referenceModule/enum/.gitkeep')));
+    assert(!fs.existsSync(config.output.directory));
+    console.log('Micro-functions layout passed: module grouping, routes, service APIs, enums, and cross-service imports.');
+  } finally { await fs.remove(root); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/test/performance-generation.js

@@ -0,0 +1,32 @@
+const assert=require('node:assert/strict'),fs=require('fs-extra'),path=require('path'),os=require('os');
+const {generateFromSource}=require('../src');
+const {generateProject}=require('../src/generator/project-output');
+const {validateConfig}=require('../src/config/load-config');
+(async()=>{
+ const root=await fs.mkdtemp(path.join(os.tmpdir(),'crudforge-performance-check-'));
+ try {
+  const schema=await fs.readFile(path.join(__dirname,'fixtures/performance/large.gdl'),'utf8');
+  for(const mode of ['spa','ssr']) {
+   const output=path.join(root,mode);const result=await generateFromSource(schema,{configPath:path.join(__dirname,'fixtures/performance/config.yml'),fileType:'gdl',outputDirectory:output,fuse:{enabled:true,rendering:mode,starterPackPath:path.resolve('fuse-starter-pack/fuse-v21.1')}});
+   const angular=await fs.readJson(path.join(output,'angular.json'));const options=angular.projects.fuse.architect.build.options;
+   const ts=await fs.readJson(path.join(output,'tsconfig.app.json'));const strict=await fs.readJson(path.join(output,'tsconfig.json')).catch(()=>JSON.parse(fs.readFileSync(path.join(output,'tsconfig.json'),'utf8').replace(/\/\*[\s\S]*?\*\//g,'').replace(/^\/\/.*$/gm,'')));
+   assert.equal(strict.compilerOptions.strict,true);assert.equal(strict.angularCompilerOptions.strictTemplates,true);
+   assert.equal(!!options.ssr,mode==='ssr');assert.equal(ts.files.includes('src/server.ts'),mode==='ssr');assert.deepEqual(ts.include,['src/**/*.d.ts']);
+   const app=await fs.readFile(path.join(output,'src/app/app.config.ts'),'utf8');assert.equal(app.includes('provideClientHydration'),mode==='ssr');assert.ok(app.includes('withInterceptors([authInterceptor])'));
+   const pkg=await fs.readJson(path.join(output,'package.json'));const lock=await fs.readJson(path.join(output,'package-lock.json'));assert.deepEqual(lock.packages[''].dependencies,pkg.dependencies);assert.equal(!!pkg.dependencies['@angular/ssr'],mode==='ssr');
+   const docker=await fs.readFile(path.join(output,'Dockerfile'),'utf8');assert.equal(docker.includes('dist/fuse/server/server.mjs'),mode==='ssr');
+   const files=[];async function walk(dir){for(const entry of await fs.readdir(dir,{withFileTypes:true})){const p=path.join(dir,entry.name);if(entry.isDirectory())await walk(p);else files.push(p);}}await walk(path.join(output,'src'));
+   for(const name of ['confirmation-dialog.component.ts','resizable.directive.ts','list-styles.css','snackbar-styles.css'])assert.equal(files.filter(f=>path.basename(f)===name).length,1,name);
+   for(const file of files.filter(f=>f.endsWith('.ts'))){const code=await fs.readFile(file,'utf8');assert.ok(!code.includes('HttpClientModule'),file);}
+   const routes=files.filter(f=>/catalog-\d+\.routes\.ts$/.test(f));assert.equal(routes.length,24);for(const file of routes)assert.ok((await fs.readFile(file,'utf8')).includes('loadComponent: () => import('));
+   // Existing overwrite policy protects developer customization of a shared component.
+   if(mode==='spa') {
+    const shared=files.find(f=>path.basename(f)==='confirmation-dialog.component.ts');await fs.appendFile(shared,'\n// developer customization\n');result.config.output.overwritePolicy='fail';
+    await assert.rejects(generateProject(result.parsed,result.config), /conflict|existing|overwrite/i);
+    assert.ok((await fs.readFile(shared,'utf8')).includes('developer customization'));
+   }
+  }
+  assert.throws(()=>validateConfig({fuse:{rendering:'invalid'}},'config.yml'),/fuse.rendering/);
+  console.log('Performance generation passed: SPA/SSR coherence, strict checks, 25 entities, shared assets, lazy screens, root HTTP and overwrite protection.');
+ }finally{await fs.remove(root);}
+})().catch(e=>{console.error(e);process.exitCode=1;});