fix: create new annotationFile

packages/adp-tooling/src/base/abap.ts

@@ -29,7 +29,22 @@ export async function getManifest(appId: string, adpConfig: AdpPreviewConfig, lo
     }
     try {
         const response = await provider.get(manifestUrl);
-        return JSON.parse(response.data);
+        const manifest = JSON.parse(response.data);
+
+        // retrieve localmetadata from base project
+        const dataSourceName = Object.keys(manifest?.['sap.app']?.dataSources)?.[0];
+        const metadataPath = manifest?.['sap.app']?.dataSources?.[dataSourceName];
+        let metadataUrl = '';
+        if (metadataPath?.settings?.localUri) {//v2
+            metadataUrl = `${appInfo.url}/${metadataPath.settings.localUri}`;
+        } else if (metadataPath?.uri) { //v4
+            metadataUrl = `${appInfo.url}/${metadataPath.uri}$metadata`; 
+        }
+
+        const metadata = await provider.get(metadataUrl);
+
+        console.log(metadata.data);
+        return manifest;
     } catch (error) {
         if (isAxiosError(error)) {
             logger.error('Manifest fetching failed');

packages/adp-tooling/src/base/change-utils.ts

@@ -1,5 +1,5 @@
 import type { Dirent } from 'fs';
-import path from 'path';
+import { join, dirname, posix, resolve } from 'path';
 import type { Editor } from 'mem-fs-editor';
 import { existsSync, readFileSync, readdirSync } from 'fs';
 
@@ -13,6 +13,7 @@ import {
     type ManifestChangeProperties,
     type PropertyValueType
 } from '../types';
+import { renderFile } from 'ejs';
 
 export type ChangeMetadata = Pick<DescriptorVariant, 'id' | 'layer' | 'namespace'>;
 
@@ -40,26 +41,32 @@ export function writeAnnotationChange(
 ): void {
     try {
         const changeFileName = `id_${timestamp}_addAnnotationsToOData.change`;
-        const changesFolderPath = path.join(projectPath, DirName.Webapp, DirName.Changes);
-        const changeFilePath = path.join(changesFolderPath, DirName.Manifest, changeFileName);
-        const annotationsFolderPath = path.join(changesFolderPath, DirName.Annotations);
+        const changesFolderPath = join(projectPath, DirName.Webapp, DirName.Changes);
+        const changeFilePath = join(changesFolderPath, DirName.Manifest, changeFileName);
+        const annotationsFolderPath = join(changesFolderPath, DirName.Annotations);
 
         writeChangeToFile(changeFilePath, change, fs);
 
         if (!annotation.filePath) {
-            const annotationsTemplate = path.join(
+            const annotationsTemplate = join(
                 __dirname,
                 '..',
                 '..',
                 'templates',
                 'changes',
                 TemplateFileName.Annotation
             );
-            fs.copy(annotationsTemplate, path.join(annotationsFolderPath, annotation.fileName ?? ''));
+            const { namespaces, serviceUrl: path } = annotation;
+            renderFile(annotationsTemplate, { namespaces: namespaces, path: path }, {}, async (err, str) => {
+                if (err) {
+                    throw new Error('Error rendering template: ' + err.message);
+                }
+                fs.write(join(annotationsFolderPath, annotation.fileName ?? ''), str);
+            });
         } else {
-            const selectedDir = path.dirname(annotation.filePath);
+            const selectedDir = dirname(annotation.filePath);
             if (selectedDir !== annotationsFolderPath) {
-                fs.copy(annotation.filePath, path.join(annotationsFolderPath, annotation.fileName ?? ''));
+                fs.copy(annotation.filePath, join(annotationsFolderPath, annotation.fileName ?? ''));
             }
         }
     } catch (e) {
@@ -86,13 +93,13 @@ export function writeChangeToFolder(
     dir = ''
 ): void {
     try {
-        let targetFolderPath = path.join(projectPath, DirName.Webapp, DirName.Changes);
+        let targetFolderPath = join(projectPath, DirName.Webapp, DirName.Changes);
 
         if (dir) {
-            targetFolderPath = path.join(targetFolderPath, dir);
+            targetFolderPath = join(targetFolderPath, dir);
         }
 
-        const filePath = path.join(targetFolderPath, fileName);
+        const filePath = join(targetFolderPath, fileName);
         writeChangeToFile(filePath, change, fs);
     } catch (e) {
         throw new Error(`Could not write change to folder. Reason: ${e.message}`);
@@ -187,7 +194,7 @@ export function getChangesByType(
 
         const changeFiles: ManifestChangeProperties[] = fileNames
             .map((fileName) => {
-                const filePath = path.resolve(targetDir, fileName);
+                const filePath = resolve(targetDir, fileName);
                 const fileContent = readFileSync(filePath, 'utf-8');
                 const change: ManifestChangeProperties = JSON.parse(fileContent);
                 return change;
@@ -212,7 +219,7 @@ export function findChangeWithInboundId(projectPath: string, inboundId: string):
     let changeObj: InboundChange | undefined;
     let filePath = '';
 
-    const pathToInboundChangeFiles = path.join(projectPath, DirName.Webapp, DirName.Changes, DirName.Manifest);
+    const pathToInboundChangeFiles = join(projectPath, DirName.Webapp, DirName.Changes, DirName.Manifest);
 
     if (!existsSync(pathToInboundChangeFiles)) {
         return {
@@ -227,7 +234,7 @@ export function findChangeWithInboundId(projectPath: string, inboundId: string):
         );
 
         for (const file of files) {
-            const pathToFile = path.join(pathToInboundChangeFiles, file.name);
+            const pathToFile = join(pathToInboundChangeFiles, file.name);
             const change: InboundChange = JSON.parse(readFileSync(pathToFile, 'utf-8'));
 
             if (change.content?.inboundId === inboundId) {
@@ -263,7 +270,7 @@ export function getChange(
 ): ManifestChangeProperties {
     return {
         fileName: `id_${timestamp}`,
-        namespace: path.posix.join(namespace, DirName.Changes),
+        namespace: posix.join(namespace, DirName.Changes),
         layer,
         fileType: 'change',
         creation: new Date(timestamp).toISOString(),

packages/adp-tooling/src/preview/adp-preview.ts

@@ -12,6 +12,7 @@
 import type { AdpPreviewConfig, CommonChangeProperties, DescriptorVariant, OperationType } from '../types';
 import type { Editor } from 'mem-fs-editor';
 import { addXmlFragment, isAddXMLChange, moduleNameContentMap, tryFixChange } from './change-handler';
+import { join } from 'path';
 
 declare global {
     // false positive, const can't be used here https://github.com/eslint/eslint/issues/15896
@@ -22,7 +23,8 @@
 export const enum ApiRoutes {
     FRAGMENT = '/adp/api/fragment',
     CONTROLLER = '/adp/api/controller',
-    CODE_EXT = '/adp/api/code_ext/:controllerName'
+    CODE_EXT = '/adp/api/code_ext/:controllerName',
+    ANNOTATION_FILE = '/adp/api/annotation'
 }
 
 /**
@@ -198,6 +200,8 @@
         router.post(ApiRoutes.CONTROLLER, this.routesHandler.handleWriteControllerExt as RequestHandler);
 
         router.get(ApiRoutes.CODE_EXT, this.routesHandler.handleGetControllerExtensionData as RequestHandler);
+
+        router.post(ApiRoutes.ANNOTATION_FILE, this.routesHandler.handleCreateAnnoationFile as RequestHandler);
     }
 
     /**

packages/adp-tooling/src/preview/change-handler.ts

@@ -1,5 +1,5 @@
 import type { Editor } from 'mem-fs-editor';
-import type { AddXMLChange, CommonChangeProperties, CodeExtChange } from '../types';
+import { type AddXMLChange, type CommonChangeProperties, type CodeExtChange, DescriptorVariant } from '../types';
 import { join } from 'path';
 import { DirName } from '@sap-ux/project-access';
 import type { Logger } from '@sap-ux/logger';

packages/adp-tooling/src/preview/routes-handler.ts

@@ -11,13 +11,21 @@ import type { NextFunction, Request, Response } from 'express';
 
 import { TemplateFileName, HttpStatusCodes } from '../types';
 import { DirName } from '@sap-ux/project-access';
-import type { CodeExtChange } from '../types';
+import { ChangeType, CodeExtChange } from '../types';
+import { generateChange } from '../writer/editors';
 
 interface WriteControllerBody {
     controllerName: string;
     projectId: string;
 }
 
+export interface WriteAnnotationFile {
+    datasource: string;
+    namespaces: { namespace: string; alias: string }[];
+    path: string;
+    odataVersion: '2.0' | '4.0';
+}
+
 /**
  * @description Handles API Routes
  */
@@ -244,4 +252,71 @@ export default class RoutesHandler {
             next(e);
         }
     };
+
+    public handleCreateAnnoationFile = async (req: Request, res: Response, next: NextFunction) => {
+        try {
+            const data = req.body as WriteAnnotationFile;
+
+            const annotationFileName = sanitize('annotation0');
+            // const projectId = data.projectId;
+            const projectPath = this.util.getProject().getRootPath();
+            const sourcePath = this.util.getProject().getSourcePath();
+
+            if (!annotationFileName) {
+                res.status(HttpStatusCodes.BAD_REQUEST).send('Annotation File name was not provided!');
+                this.logger.debug('Bad request. Annotation File name was not provided!');
+                return;
+            }
+
+            const fullPath = path.join(sourcePath, DirName.Annotations);
+            const filePath = path.join(fullPath, `${annotationFileName}.xml`);
+
+            if (!fs.existsSync(fullPath)) {
+                fs.mkdirSync(fullPath, { recursive: true });
+            }
+
+            if (fs.existsSync(filePath)) {
+                res.status(HttpStatusCodes.CONFLICT).send(
+                    `Annotation file with name "${annotationFileName}" already exists`
+                );
+                this.logger.debug(`Annotation file with name name "${annotationFileName}" already exists`);
+                return;
+            }
+
+            const annatationFilePath = path.join(__dirname, '../../templates/changes', TemplateFileName.Annotation);
+
+            // renderFile(annatationFilePath, { ...data }, {}, async (err, str) => {
+            //     if (err) {
+            //         throw new Error('Error rendering template: ' + err.message);
+            //     }
+            const { datasource, namespaces, path: serviceUrl, odataVersion } = data;
+            const fsEditor = await generateChange<ChangeType.ADD_ANNOTATIONS_TO_ODATA>(
+                projectPath,
+                ChangeType.ADD_ANNOTATIONS_TO_ODATA,
+                {
+                    annotation: {
+                        fileName: 'annotation0.xml',
+                        datasource,
+                        namespaces,
+                        serviceUrl,
+                        odataVersion
+                    },
+                    variant: JSON.parse(
+                        fs.readFileSync(path.join(sourcePath, 'manifest.appdescr_variant')).toString('utf-8')
+                    )
+                }
+            );
+            fsEditor.commit((err) => this.logger.error(err));
+            // });
+
+            const message = 'Annotation file created!';
+            res.status(HttpStatusCodes.CREATED).send(message);
+            this.logger.debug(`Annotation file with name "${annotationFileName}" was created`);
+        } catch (e) {
+            const sanitizedMsg = sanitize(e.message);
+            this.logger.error(sanitizedMsg);
+            res.status(HttpStatusCodes.INTERNAL_SERVER_ERROR).send(sanitizedMsg);
+            next(e);
+        }
+    };
 }

packages/adp-tooling/src/types.ts

@@ -190,6 +190,27 @@ export interface AddXMLChange extends CommonChangeProperties {
     jsOnly: boolean;
 }
 
+export interface AddAnnotationToOdata extends CommonChangeProperties {
+    changeType: ChangeType.ADD_ANNOTATIONS_TO_ODATA;
+    creation: string;
+    packageName: string;
+    content: {
+        datasourceId: string;
+        annotations: string[];
+        annotationsInsertPosition: 'END';
+        datasource: {
+            [key: string]: {
+                uri: string;
+                type: 'ODataAnntation';
+            };
+        };
+    };
+    selector: {
+        id: string;
+        idIsLocal: boolean;
+    };
+}
+
 export interface CodeExtChange extends CommonChangeProperties {
     changeType: 'codeExt';
     content: {
@@ -302,9 +323,12 @@ export interface AnnotationsData {
         /** Optional name of the annotation file. */
         fileName?: string;
         /** Data source associated with the annotation. */
-        dataSource: string;
+        datasource: string;
         /** Optional path to the annotation file. */
         filePath?: string;
+        namespaces?: { namespace: string; alias: string }[];
+        serviceUrl?: string;
+        odataVersion?: '2.0' | '4.0';
     };
 }
 

packages/adp-tooling/src/writer/changes/writers/annotations-writer.ts

@@ -24,15 +24,15 @@ export class AnnotationsWriter implements IWriter<AnnotationsData> {
     private constructContent(data: AnnotationsData): object {
         const {
             variant: { layer },
-            annotation: { dataSource, fileName }
+            annotation: { datasource, fileName }
         } = data;
         const annotationFileNameWithoutExtension = fileName?.toLocaleLowerCase().replace('.xml', '');
         const annotationNameSpace =
             layer === FlexLayer.CUSTOMER_BASE
                 ? `customer.annotation.${annotationFileNameWithoutExtension}`
                 : `annotation.${annotationFileNameWithoutExtension}`;
         return {
-            dataSourceId: `${dataSource}`,
+            dataSourceId: `${datasource}`,
             annotations: [annotationNameSpace],
             annotationsInsertPosition: 'END',
             dataSource: {
@@ -71,6 +71,6 @@ export class AnnotationsWriter implements IWriter<AnnotationsData> {
         const content = this.constructContent(data);
         const timestamp = Date.now();
         const change = getChange(variant, timestamp, content, ChangeType.ADD_ANNOTATIONS_TO_ODATA);
-        writeAnnotationChange(this.projectPath, timestamp, data.annotation, change, this.fs);
+        writeAnnotationChange(this.projectPath, timestamp, annotation, change, this.fs);
     }
 }

packages/adp-tooling/templates/changes/annotation.xml

@@ -7,6 +7,9 @@
     </edmx:Reference>
     <edmx:Reference Uri="https://sap.github.io/odata-vocabularies/vocabularies/Communication.xml">
         <edmx:Include Namespace="com.sap.vocabularies.Communication.v1" Alias="Communication"/>
+    </edmx:Reference>
+     <edmx:Reference Uri="<%- path %>/$metadata"><% namespaces.forEach(function(namespace){ %>
+        <edmx:Include Namespace="<%- namespace.namespace %>"<% if (namespace.alias) { %> Alias="<%- namespace.alias %>"<% } %>/><% }); %>
     </edmx:Reference>
     <edmx:DataServices>
         <Schema xmlns="http://docs.oasis-open.org/odata/ns/edm" Namespace="local">

packages/create/src/cli/add/annotations-to-odata.ts

@@ -52,7 +52,7 @@ async function addAnnotationsToOdata(basePath: string, simulate: boolean, yamlPa
             {
                 variant,
                 annotation: {
-                    dataSource: answers.id,
+                    datasource: answers.id,
                     filePath: answers.filePath
                 }
             }

packages/preview-middleware-client/src/adp/api-handler.ts

@@ -6,6 +6,7 @@ export const enum ApiEndpoints {
     FRAGMENT = '/adp/api/fragment',
     CONTROLLER = '/adp/api/controller',
     CODE_EXT = '/adp/api/code_ext',
+    ANNOTATION_FILE = '/adp/api/annotation',
     MANIFEST_APP_DESCRIPTOR = '/manifest.appdescr_variant'
 }
 
@@ -139,6 +140,16 @@ export async function writeController<T>(data: T): Promise<T> {
     return request<T>(ApiEndpoints.CONTROLLER, RequestMethod.POST, data);
 }
 
+/**
+ * Writes a new annotation file to the project's workspace
+ *
+ * @param data Data to be send to the server
+ * @returns Generic Promise<T>
+ */
+export async function writeAnnotationFle<T>(data: T): Promise<T> {
+    return request<T>(ApiEndpoints.ANNOTATION_FILE, RequestMethod.POST, data);
+}
+
 /**
  * Checks for existing controller in the project's workspace
  *