@cspeach/cli 0.6.3 → 0.6.4

package/dist/project-context/__tests__/domain-abap-cloud.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { extractAbapCloud } from '../domain/abap-cloud.js';
+let root;
+beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-abap-cloud-'));
+});
+afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+});
+async function writeFile(rel, content = '') {
+    const full = path.join(root, rel);
+    await fs.mkdir(path.dirname(full), { recursive: true });
+    await fs.writeFile(full, content, 'utf-8');
+}
+describe('extractAbapCloud — empty / missing', () => {
+    it('returns empty objects + empty behaviorDefinitions when src/ is absent', async () => {
+        const result = await extractAbapCloud(root);
+        expect(result).toEqual({
+            type: 'abap-cloud',
+            objects: [],
+            behaviorDefinitions: [],
+        });
+    });
+    it('returns empty arrays for a src/ with no recognized abap files', async () => {
+        await writeFile('src/notes.txt');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        expect(result.objects).toEqual([]);
+        expect(result.behaviorDefinitions).toEqual([]);
+    });
+});
+describe('extractAbapCloud — happy path', () => {
+    it('promotes behavior definitions into a dedicated list', async () => {
+        await writeFile('src/zr_order.bdef.asbdef', '');
+        await writeFile('src/zr_invoice.bdef.asbdef', '');
+        await writeFile('src/zcl_order_helper.clas.abap', '');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        expect(result.behaviorDefinitions.sort()).toEqual(['ZR_INVOICE', 'ZR_ORDER']);
+    });
+    it('still surfaces non-BDEF RAP objects in objects[]', async () => {
+        await writeFile('src/zsd_order.srvd.srvd', '');
+        await writeFile('src/zsd_order.srvb.srvb', '');
+        await writeFile('src/zr_order.dcls.asdcls', '');
+        await writeFile('src/zc_order.ddlx.asddlx', '');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        const types = result.objects.map((o) => o.type).sort();
+        expect(types).toEqual(['DCLS', 'DDLX', 'SRVB', 'SRVD']);
+        // None of these are BDEFs.
+        expect(result.behaviorDefinitions).toEqual([]);
+    });
+    it('infers package from folder for cloud objects too', async () => {
+        await writeFile('src/zsd/zsd_order/zr_order.bdef.asbdef', '');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        expect(result.objects[0]).toMatchObject({
+            name: 'ZR_ORDER',
+            type: 'BDEF',
+            package: 'ZSD_ORDER',
+        });
+    });
+});
+describe('extractAbapCloud — realistic RAP stack', () => {
+    it('handles a complete RAP root entity stack', async () => {
+        await writeFile('src/zsd/zsd_orders/ztorder.tabl.xml', '');
+        await writeFile('src/zsd/zsd_orders/zi_order.ddls.asddls', '');
+        await writeFile('src/zsd/zsd_orders/zc_order.ddls.asddls', '');
+        await writeFile('src/zsd/zsd_orders/zc_order.ddlx.asddlx', '');
+        await writeFile('src/zsd/zsd_orders/zr_order.bdef.asbdef', '');
+        await writeFile('src/zsd/zsd_orders/zbp_zr_order.clas.abap', '');
+        await writeFile('src/zsd/zsd_orders/zsd_order.srvd.srvd', '');
+        await writeFile('src/zsd/zsd_orders/zsd_order_o4.srvb.srvb', '');
+        await writeFile('src/zsd/zsd_orders/zr_order.dcls.asdcls', '');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        // 9 distinct objects, all in package ZSD_ORDERS.
+        expect(result.objects).toHaveLength(9);
+        expect(result.objects.every((o) => o.package === 'ZSD_ORDERS')).toBe(true);
+        expect(result.behaviorDefinitions).toEqual(['ZR_ORDER']);
+    });
+    it('returns behavior definitions in the same order they appear in objects[]', async () => {
+        // objects[] is sorted by name then type — behaviorDefinitions inherits that.
+        await writeFile('src/zr_omega.bdef.asbdef', '');
+        await writeFile('src/zr_alpha.bdef.asbdef', '');
+        await writeFile('src/zr_middle.bdef.asbdef', '');
+        const result = await extractAbapCloud(root);
+        if (result.type !== 'abap-cloud')
+            throw new Error('wrong variant');
+        expect(result.behaviorDefinitions).toEqual(['ZR_ALPHA', 'ZR_MIDDLE', 'ZR_OMEGA']);
+    });
+});
+describe('extractAbapCloud — fault tolerance', () => {
+    it('does not throw on missing cwd', async () => {
+        const result = await extractAbapCloud(path.join(root, 'nope'));
+        expect(result).toEqual({
+            type: 'abap-cloud',
+            objects: [],
+            behaviorDefinitions: [],
+        });
+    });
+    it('does not throw when src is a file', async () => {
+        await writeFile('src', 'not a dir');
+        const result = await extractAbapCloud(root);
+        expect(result).toEqual({
+            type: 'abap-cloud',
+            objects: [],
+            behaviorDefinitions: [],
+        });
+    });
+});

package/dist/project-context/__tests__/domain-abapgit.test.js

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { extractAbapGit, parseAbapFilename } from '../domain/abapgit.js';
+let root;
+beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-abapgit-'));
+});
+afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+});
+async function writeFile(rel, content = '') {
+    const full = path.join(root, rel);
+    await fs.mkdir(path.dirname(full), { recursive: true });
+    await fs.writeFile(full, content, 'utf-8');
+}
+describe('parseAbapFilename', () => {
+    it('parses program filename', () => {
+        expect(parseAbapFilename('zhello.prog.abap')).toEqual({ name: 'ZHELLO', type: 'PROG' });
+    });
+    it('parses class filename', () => {
+        expect(parseAbapFilename('zcl_foo.clas.abap')).toEqual({ name: 'ZCL_FOO', type: 'CLAS' });
+    });
+    it('parses interface filename', () => {
+        expect(parseAbapFilename('zif_bar.intf.abap')).toEqual({ name: 'ZIF_BAR', type: 'INTF' });
+    });
+    it('parses table xml filename', () => {
+        expect(parseAbapFilename('ztab.tabl.xml')).toEqual({ name: 'ZTAB', type: 'TABL' });
+    });
+    it('parses CDS DDLS filename', () => {
+        expect(parseAbapFilename('zi_view.ddls.asddls')).toEqual({ name: 'ZI_VIEW', type: 'DDLS' });
+    });
+    it('returns null for non-conforming filenames', () => {
+        expect(parseAbapFilename('README.md')).toBeNull();
+        expect(parseAbapFilename('.gitignore')).toBeNull();
+        expect(parseAbapFilename('package.json')).toBeNull();
+    });
+    it('returns null when type token is unknown', () => {
+        // .foo. is not a recognized abapGit type segment.
+        expect(parseAbapFilename('zsomething.foo.abap')).toBeNull();
+    });
+    it('uppercases lowercase object names', () => {
+        expect(parseAbapFilename('mixed_Case.clas.abap')).toEqual({
+            name: 'MIXED_CASE',
+            type: 'CLAS',
+        });
+    });
+});
+describe('extractAbapGit — empty / missing src', () => {
+    it('returns empty objects when src/ is absent', async () => {
+        const result = await extractAbapGit(root);
+        expect(result).toEqual({ type: 'abapgit', objects: [] });
+    });
+    it('returns empty objects when src/ has no abap files', async () => {
+        await writeFile('src/notes.txt', 'just a note');
+        await writeFile('src/README.md', '# repo');
+        const result = await extractAbapGit(root);
+        expect(result.type).toBe('abapgit');
+        if (result.type === 'abapgit') {
+            expect(result.objects).toEqual([]);
+        }
+    });
+});
+describe('extractAbapGit — happy path', () => {
+    it('collects mixed object types from a flat src/', async () => {
+        await writeFile('src/zhello.prog.abap', 'REPORT zhello.');
+        await writeFile('src/zcl_foo.clas.abap', 'CLASS zcl_foo DEFINITION.');
+        await writeFile('src/zif_bar.intf.abap', 'INTERFACE zif_bar.');
+        await writeFile('src/ztab.tabl.xml', '<xml/>');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        const names = result.objects.map((o) => `${o.name}:${o.type}`).sort();
+        expect(names).toEqual([
+            'ZCL_FOO:CLAS',
+            'ZHELLO:PROG',
+            'ZIF_BAR:INTF',
+            'ZTAB:TABL',
+        ]);
+    });
+    it('infers package from the immediate parent folder, uppercased', async () => {
+        await writeFile('src/zfi/zfi_payments/zcl_payment.clas.abap', '');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        expect(result.objects).toHaveLength(1);
+        expect(result.objects[0]).toMatchObject({
+            name: 'ZCL_PAYMENT',
+            type: 'CLAS',
+            package: 'ZFI_PAYMENTS',
+        });
+    });
+    it('uses forward-slash relative paths regardless of platform', async () => {
+        await writeFile('src/zfi/zhello.prog.abap', '');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        expect(result.objects[0].path).toBe('src/zfi/zhello.prog.abap');
+    });
+    it('dedupes multi-file objects (e.g. class + locals)', async () => {
+        // abapGit emits multiple files per class — main + locals_def + locals_imp + tests.
+        // All share the same (name, type) pair; we keep only the first.
+        await writeFile('src/zcl_foo.clas.abap', '');
+        await writeFile('src/zcl_foo.clas.locals_def.abap', '');
+        await writeFile('src/zcl_foo.clas.locals_imp.abap', '');
+        await writeFile('src/zcl_foo.clas.testclasses.abap', '');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        // The dedup key is name+type, but the secondary files like
+        // .clas.locals_def.abap have type 'LOCALS_DEF' (unknown) and are
+        // skipped at parse time. Only the main .clas.abap survives.
+        const clasEntries = result.objects.filter((o) => o.name === 'ZCL_FOO' && o.type === 'CLAS');
+        expect(clasEntries).toHaveLength(1);
+    });
+});
+describe('extractAbapGit — realistic package fixture', () => {
+    it('handles a small multi-package repo', async () => {
+        await writeFile('src/package.devc.xml', '<xml/>');
+        await writeFile('src/zfi_root.devc.xml', '<xml/>');
+        await writeFile('src/zfi/zfi_payments.devc.xml', '<xml/>');
+        await writeFile('src/zfi/zfi_payments/zcl_payment.clas.abap', '');
+        await writeFile('src/zfi/zfi_payments/zif_payment.intf.abap', '');
+        await writeFile('src/zfi/zfi_payments/zpayment.tabl.xml', '');
+        await writeFile('src/zhr/zhr_employee.clas.abap', '');
+        await writeFile('src/README.md', '# repo');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        const byKey = new Map(result.objects.map((o) => [`${o.name}:${o.type}`, o]));
+        expect(byKey.size).toBe(7);
+        expect(byKey.get('ZCL_PAYMENT:CLAS')?.package).toBe('ZFI_PAYMENTS');
+        expect(byKey.get('ZIF_PAYMENT:INTF')?.package).toBe('ZFI_PAYMENTS');
+        expect(byKey.get('ZHR_EMPLOYEE:CLAS')?.package).toBe('ZHR');
+    });
+    it('returns objects sorted by name then type for stable ordering', async () => {
+        await writeFile('src/zbeta.prog.abap', '');
+        await writeFile('src/zalpha.prog.abap', '');
+        await writeFile('src/zalpha.tabl.xml', '');
+        const result = await extractAbapGit(root);
+        if (result.type !== 'abapgit')
+            throw new Error('wrong variant');
+        expect(result.objects.map((o) => `${o.name}:${o.type}`)).toEqual([
+            'ZALPHA:PROG',
+            'ZALPHA:TABL',
+            'ZBETA:PROG',
+        ]);
+    });
+});
+describe('extractAbapGit — fault tolerance', () => {
+    it('does not throw when src is a file rather than a directory', async () => {
+        await writeFile('src', 'not a dir');
+        const result = await extractAbapGit(root);
+        expect(result).toEqual({ type: 'abapgit', objects: [] });
+    });
+    it('does not throw when cwd does not exist', async () => {
+        const result = await extractAbapGit(path.join(root, 'nope'));
+        expect(result).toEqual({ type: 'abapgit', objects: [] });
+    });
+});

package/dist/project-context/__tests__/domain-cap.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { extractCap } from '../domain/cap.js';
+let root;
+beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-cap-'));
+});
+afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+});
+async function writeFile(rel, content = '') {
+    const full = path.join(root, rel);
+    await fs.mkdir(path.dirname(full), { recursive: true });
+    await fs.writeFile(full, content, 'utf-8');
+}
+describe('extractCap — empty / missing', () => {
+    it('returns empty arrays when neither db/ nor srv/ exists', async () => {
+        const result = await extractCap(root);
+        expect(result).toEqual({ type: 'cap-node', services: [], entities: [] });
+    });
+    it('returns empty arrays when db/ + srv/ exist but contain no .cds', async () => {
+        await writeFile('db/notes.txt');
+        await writeFile('srv/readme.md');
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.services).toEqual([]);
+        expect(result.entities).toEqual([]);
+    });
+});
+describe('extractCap — happy path', () => {
+    it('extracts service names from srv/*.cds', async () => {
+        await writeFile('srv/cat-service.cds', `using my.bookshop from '../db/schema';
+
+       service CatalogService {
+         entity Books as projection on bookshop.Books;
+         entity Authors as projection on bookshop.Authors;
+       }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.services.map((s) => s.name)).toEqual(['CatalogService']);
+        const cat = result.services[0];
+        expect(cat.path).toBe('srv/cat-service.cds');
+        expect(cat.entities.sort()).toEqual(['Authors', 'Books']);
+    });
+    it('extracts entity names from db/*.cds', async () => {
+        await writeFile('db/schema.cds', `namespace my.bookshop;
+
+       entity Books {
+         key ID : Integer;
+         title  : String;
+       }
+
+       entity Authors {
+         key ID : Integer;
+         name   : String;
+       }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.entities.map((e) => e.name).sort()).toEqual(['Authors', 'Books']);
+        expect(result.entities.every((e) => e.path === 'db/schema.cds')).toBe(true);
+    });
+    it('flags @cds.persistence.exists entities as external-table sourced', async () => {
+        await writeFile('db/external.cds', `@cds.persistence.exists
+       entity LegacyMaterial {
+         key Matnr : String;
+       }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.entities[0]).toMatchObject({
+            name: 'LegacyMaterial',
+            source: 'external-table',
+        });
+    });
+    it('handles multiple services declared across multiple files', async () => {
+        await writeFile('srv/admin.cds', 'service AdminService { entity Logs; }');
+        await writeFile('srv/public.cds', 'service PublicService { entity Catalog; }');
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.services.map((s) => s.name)).toEqual(['AdminService', 'PublicService']);
+    });
+});
+describe('extractCap — comment + dedup handling', () => {
+    it('ignores entity declarations inside line comments', async () => {
+        await writeFile('db/schema.cds', `// entity Disabled { ... }
+       entity RealOne { key ID : Integer; }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.entities.map((e) => e.name)).toEqual(['RealOne']);
+    });
+    it('dedupes a service-file entity referenced multiple times', async () => {
+        // CAP allows redeclaration / re-projection — we want one entry per name.
+        await writeFile('srv/dup.cds', `service S { entity Item; }
+       extend service S with { entity Item; }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.services[0].entities).toEqual(['Item']);
+    });
+});
+describe('extractCap — realistic bookshop fixture', () => {
+    it('extracts a small bookshop project', async () => {
+        await writeFile('db/schema.cds', `namespace sap.capire.bookshop;
+
+       entity Books {
+         key ID : Integer;
+         title  : localized String;
+         author : Association to Authors;
+         stock  : Integer;
+       }
+
+       entity Authors {
+         key ID : Integer;
+         name   : String;
+         books  : Composition of many Books on books.author = $self;
+       }
+
+       entity Genres {
+         key ID : Integer;
+         name   : String;
+       }`);
+        await writeFile('srv/cat-service.cds', `using sap.capire.bookshop as my from '../db/schema';
+
+       service CatalogService @(path:'/browse') {
+         @readonly entity Books as projection on my.Books;
+         @readonly entity Authors as projection on my.Authors;
+       }`);
+        await writeFile('srv/admin-service.cds', `using sap.capire.bookshop as my from '../db/schema';
+
+       service AdminService {
+         entity Books as projection on my.Books;
+         entity Authors as projection on my.Authors;
+         entity Genres as projection on my.Genres;
+       }`);
+        const result = await extractCap(root);
+        if (result.type !== 'cap-node')
+            throw new Error('wrong variant');
+        expect(result.services.map((s) => s.name).sort()).toEqual([
+            'AdminService',
+            'CatalogService',
+        ]);
+        const admin = result.services.find((s) => s.name === 'AdminService');
+        expect(admin.entities.sort()).toEqual(['Authors', 'Books', 'Genres']);
+        const dbEntities = result.entities.filter((e) => e.path === 'db/schema.cds');
+        expect(dbEntities.map((e) => e.name).sort()).toEqual(['Authors', 'Books', 'Genres']);
+    });
+});
+describe('extractCap — fault tolerance', () => {
+    it('does not throw on missing cwd', async () => {
+        const result = await extractCap(path.join(root, 'nope'));
+        expect(result).toEqual({ type: 'cap-node', services: [], entities: [] });
+    });
+    it('skips files larger than the safety cap (best-effort, no crash)', async () => {
+        // Write a 1.5 MB .cds file with a real entity declaration; we should
+        // skip it (size cap) and still return cleanly.
+        const padding = 'x'.repeat(1_500_000);
+        await writeFile('db/huge.cds', `entity Real { key ID : Integer; } // ${padding}`);
+        const result = await extractCap(root);
+        expect(result).toEqual({ type: 'cap-node', services: [], entities: [] });
+    });
+});