@cspeach/cli 0.6.4 → 0.6.5

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

@@ -1,119 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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: [] });
-    });
-});