@ui5/task-adaptation 1.6.8 → 1.7.0

package/dist/bundle.js

@@ -4342,8 +4342,9 @@ _KeyPredicateParser.prototype.parse = function (sKeyPredicate) {
   this.finish();
   return oKeyProperties;
 };
-function _SystemQueryOptionParser() {
+function _SystemQueryOptionParser(bParseFilter) {
   _Parser.apply(this, arguments);
+  this.oFilterParser = bParseFilter ? new _FilterParser() : undefined;
 }
 _SystemQueryOptionParser.prototype = Object.create(_Parser.prototype);
 _SystemQueryOptionParser.prototype.parse = function (sOption) {
@@ -4429,10 +4430,17 @@ _SystemQueryOptionParser.prototype.parseSelect = function () {
   };
 };
 _SystemQueryOptionParser.prototype.parseSystemQueryOption = function () {
-  var oToken = this.advance("OPTION");
+  const oToken = this.advance("OPTION");
   switch (oToken.value) {
     case "$expand":
       return this.parseExpand();
+    case "$filter":
+      {
+        const oRaw = this.parseAnythingWithBrackets(oToken);
+        return this.oFilterParser ? {
+          $filter: this.oFilterParser.parse(oRaw.$filter)
+        } : oRaw;
+      }
     case "$select":
       return this.parseSelect();
     default:
@@ -4567,8 +4575,8 @@ var _Parser$1 = {
   parseKeyPredicate: function (sKeyPredicate) {
     return new _KeyPredicateParser().parse(sKeyPredicate);
   },
-  parseSystemQueryOption: function (sOption) {
-    return new _SystemQueryOptionParser().parse(sOption);
+  parseSystemQueryOption: function (sOption, bParseFilter) {
+    return new _SystemQueryOptionParser(bParseFilter).parse(sOption);
   },
   sODataIdentifier: sODataIdentifier,
   sWhitespace: sWhitespace
@@ -5151,7 +5159,7 @@ class LanguageTag {
 			this.variant = (aResult[4] && aResult[4].slice(1)) || null; // remove leading hyphen from capturing group
 			this.variantSubtags = this.variant ? this.variant.split('-') : [];
 			this.extension = (aResult[5] && aResult[5].slice(1)) || null; // remove leading hyphen from capturing group
-			this.extensionSubtags = this.variant ? this.variant.split('-') : [];
+			this.extensionSubtags = this.extension ? this.extension.split('-') : [];
 			this.privateUse = aResult[6] || null;
 			this.privateUseSubtags = this.privateUse ? this.privateUse.slice(2).split('-') : [];
 			// convert subtags according to the BCP47 recommendations
@@ -6847,7 +6855,7 @@ _Helper = {
     });
     _Helper.fireChange(mChangeListeners, sPath, bRemoved ? undefined : oValue);
   },
-  formatLiteral: function (vValue, sType) {
+  formatLiteral: function (vValue, sType, oTypeMetadata) {
     if (vValue === undefined) {
       throw new Error("Illegal value: undefined");
     }
@@ -6877,6 +6885,9 @@ _Helper = {
       case "Edm.String":
         return "'" + String(vValue).replace(rSingleQuote, "''") + "'";
       default:
+        if (oTypeMetadata?.$kind === "EnumType") {
+          return sType + "'" + vValue + "'";
+        }
         throw new Error("Unsupported type: " + sType);
     }
   },
@@ -7007,7 +7018,7 @@ _Helper = {
     return sPath.replace(rNotMetaContext, "").slice(1);
   },
   getMissingPropertyPaths: function (vEntityOrCollection, mQueryOptions) {
-    return (mQueryOptions.$select || []).concat(Object.keys(mQueryOptions.$expand || ({}))).filter(function (sPath) {
+    return (mQueryOptions.$select ?? []).concat(Object.keys(mQueryOptions.$expand ?? ({}))).filter(function (sPath) {
       return _Helper.isMissingProperty(vEntityOrCollection, sPath);
     });
   },
@@ -7044,7 +7055,7 @@ _Helper = {
         }
       });
     }
-    return mQueryOptions || ({});
+    return mQueryOptions ?? ({});
   },
   getRelativePath: function (sPath, sBasePath) {
     if (sBasePath.length) {
@@ -7078,8 +7089,8 @@ _Helper = {
     }
     function isUsed(sPath, mQueryOptionsForPath) {
       let bPathMatchedExpand = false;
-      const aSelect = mQueryOptionsForPath.$select || ["*"];
-      const mExpand = mQueryOptionsForPath.$expand || ({});
+      const aSelect = mQueryOptionsForPath.$select ?? ["*"];
+      const mExpand = mQueryOptionsForPath.$expand ?? ({});
       return sPath === "*" || (sPath in mExpand) || aSelect.includes(sPath) || aSelect.some(sSelect => isRelated(sPath, sSelect)) || Object.keys(mExpand).some(sExpand => {
         if (_Helper.hasPathPrefix(sPath, sExpand)) {
           bPathMatchedExpand = true;
@@ -7160,7 +7171,7 @@ _Helper = {
       throw new Error("Unsupported empty navigation property path");
     }
     if (aPaths.includes("*")) {
-      aSelects = (mCacheQueryOptions && mCacheQueryOptions.$select || []).slice();
+      aSelects = mCacheQueryOptions?.$select?.slice() ?? [];
       if (sMessagesPath && !aSelects.includes(sMessagesPath)) {
         aSelects.push(sMessagesPath);
       }
@@ -7188,7 +7199,7 @@ _Helper = {
           if (fnFetchMetadata(sMetaPath).getResult().$isCollection) {
             throw new Error("Unsupported collection-valued navigation property " + sMetaPath);
           }
-          mChildQueryOptions = _Helper.intersectQueryOptions(mCacheQueryOptions.$expand[sNavigationPropertyPath] || ({}), aStrippedPaths, fnFetchMetadata, sMetaPath, sPrefixedNavigationPropertyPath);
+          mChildQueryOptions = _Helper.intersectQueryOptions(mCacheQueryOptions.$expand[sNavigationPropertyPath] ?? ({}), aStrippedPaths, fnFetchMetadata, sMetaPath, sPrefixedNavigationPropertyPath);
           if (mChildQueryOptions) {
             mExpands[sNavigationPropertyPath] = mChildQueryOptions;
           }
@@ -7421,14 +7432,14 @@ _Helper = {
     return mHeaders;
   },
   restoreUpdatingProperties: function (oOld, oNew) {
-    var oTempNew = oNew || ({});
-    Object.keys(oOld || ({})).forEach(function (sProperty) {
+    for (const sProperty in oOld) {
       if (sProperty.startsWith("@")) {
-        return;
+        continue;
       }
       if (Array.isArray(oOld[sProperty])) {
-        return;
+        continue;
       }
+      const oTempNew = oNew ?? ({});
       if (typeof oOld[sProperty] === "object") {
         oTempNew[sProperty] = _Helper.restoreUpdatingProperties(oOld[sProperty], oTempNew[sProperty]);
       }
@@ -7437,7 +7448,7 @@ _Helper = {
         oTempNew[sProperty + "@$ui5.updating"] = oOld[sProperty + "@$ui5.updating"];
         oNew = oTempNew;
       }
-    });
+    }
     return oNew;
   },
   selectKeyProperties: function (mQueryOptions, oType) {
@@ -7506,7 +7517,7 @@ _Helper = {
         oTarget[sProperty] = vSourceProperty;
         _Helper.fireChange(mChangeListeners, sPropertyPath, vSourceProperty, false, true);
       } else if (vSourceProperty && typeof vSourceProperty === "object") {
-        vTargetProperty = oTarget[sProperty] = _Helper.updateAll(mChangeListeners, sPropertyPath, vTargetProperty || ({}), vSourceProperty);
+        vTargetProperty = oTarget[sProperty] = _Helper.updateAll(mChangeListeners, sPropertyPath, vTargetProperty ?? ({}), vSourceProperty);
         _Helper.fireChange(mChangeListeners, sPropertyPath, vTargetProperty);
       } else if (vTargetProperty !== vSourceProperty) {
         oTarget[sProperty] = vSourceProperty;
@@ -7560,19 +7571,20 @@ _Helper = {
   updateNestedCreates: function (mChangeListeners, mQueryOptions, sPath, oTargetEntity, oCreatedEntity, mSelectForMetaPath) {
     let bDeepCreate = false;
     const mQueryOptionsForEntity = _Helper.getQueryOptionsForPath(mQueryOptions, sPath);
-    Object.keys(mQueryOptionsForEntity.$expand || ({})).forEach(function (sExpandPath) {
+    for (const sExpandPath in mQueryOptionsForEntity.$expand) {
       const oNestedTargetEntity = _Helper.drillDown(oTargetEntity, sExpandPath);
       if (oNestedTargetEntity && !Array.isArray(oNestedTargetEntity)) {
         bDeepCreate = true;
       }
-    });
-    Object.keys(mSelectForMetaPath || ({})).filter(function (sMetaPath) {
-      return !sMetaPath.includes("/");
-    }).forEach(function (sSegment) {
+    }
+    for (const sSegment in mSelectForMetaPath) {
+      if (sSegment.includes("/")) {
+        continue;
+      }
       const aNestedCreatedEntities = oCreatedEntity[sSegment];
       if (!aNestedCreatedEntities) {
         delete oTargetEntity[sSegment];
-        return;
+        continue;
       }
       oTargetEntity[sSegment] = aNestedCreatedEntities;
       aNestedCreatedEntities.$count = undefined;
@@ -7596,7 +7608,7 @@ _Helper = {
         _Helper.updateNestedCreates(mChangeListeners, mQueryOptions, sCollectionPath + sPredicate, oCreatedChildEntity, oCreatedChildEntity, mSelectForChildMetaPath);
       });
       bDeepCreate = true;
-    });
+    }
     return bDeepCreate;
   },
   updateNonExisting: function (oTarget, oSource) {
@@ -7657,7 +7669,7 @@ _Helper = {
             _Helper.fireChange(mChangeListeners, sPropertyPath, vSourceProperty, false, true);
           }
         } else if (vSourceProperty && typeof vSourceProperty === "object" && !sProperty.includes("@")) {
-          oTarget[sProperty] = update(sPropertyPath, vSelected, vTargetProperty || ({}), vSourceProperty);
+          oTarget[sProperty] = update(sPropertyPath, vSelected, vTargetProperty ?? ({}), vSourceProperty);
           _Helper.fireChange(mChangeListeners, sPropertyPath, vSourceProperty);
         } else if (vTargetProperty !== vSourceProperty && !oTarget[sProperty + "@$ui5.updating"]) {
           oTarget[sProperty] = vSourceProperty;
@@ -8728,7 +8740,7 @@ _V2MetadataConverter.prototype.postProcessSchema = function (_oElement, _aResult
         continue;
       }
       sTarget = sEntityContainerName + "/" + sEntitySetName;
-      mAnnotations = _Helper$1.merge(this.convertedV2Annotations[sTarget] || ({}), this.mEntityType2EntitySetAnnotation[oEntitySet.$Type]);
+      mAnnotations = _Helper$1.merge(this.convertedV2Annotations[sTarget] ?? ({}), this.mEntityType2EntitySetAnnotation[oEntitySet.$Type]);
       if (!_Helper$1.isEmptyObject(mAnnotations)) {
         this.convertedV2Annotations[sTarget] = mAnnotations;
       }

package/dist/cache/cacheHolder.d.ts

@@ -1,18 +1,12 @@
+import ICachedResource from "./cachedResource.js";
 export default class CacheHolder {
     private static TEMP_TASK_DIR;
+    private static MERGED_DIR;
     static getTempDir(...paths: string[]): string;
-    static read(repoName: string, token: string): Promise<Map<string, Buffer>>;
-    /**
-     * Read the most recently cached files for the given repo, without knowing
-     * the cachebuster token up front. The @cached() decorator on
-     * IRepository.fetch calls delete(repoName) before every write, so there is
-     * at most one token subdirectory under <repoName>/ at any time.
-     * Returns an empty map if the repo has never been fetched
-     * (i.e. no full build has run yet).
-     */
-    static readLatest(repoName: string): Promise<Map<string, Buffer>>;
-    static write(repoName: string, token: string, files: Map<string, Buffer>): Promise<void>;
-    private static isValid;
+    static hasDirectory(resource: ICachedResource): Promise<boolean>;
+    static read(resource: ICachedResource): Promise<Map<string, Buffer>>;
+    static write(resource: ICachedResource, files: Map<string, Buffer>): Promise<void>;
+    static mergedResource(reference: string): ICachedResource;
     /**
      * Clears cached files by repo name and token
      */

package/dist/cache/cacheHolder.js

@@ -8,50 +8,38 @@ import { getLogger } from "@ui5/logger";
 const log = getLogger("@ui5/task-adaptation::CacheHolder");
 export default class CacheHolder {
     static TEMP_TASK_DIR = "ui5-task-adaptation";
+    static MERGED_DIR = "merged";
     static getTempDir(...paths) {
         return path.join(os.tmpdir(), this.TEMP_TASK_DIR, ...paths.map(part => encodeFilename(part, { replacement: "_" })));
     }
-    static read(repoName, token) {
-        const directory = this.getTempDir(repoName, token);
-        if (this.isValid(repoName, "repoName") && this.isValid(token, "token") && fs.existsSync(directory)) {
-            return ResourceUtil.byGlob(directory, "**/*");
-        }
-        return Promise.resolve(new Map());
+    static async hasDirectory(resource) {
+        const directory = this.getTempDir(resource.appName, await resource.token);
+        return fs.existsSync(directory);
     }
-    /**
-     * Read the most recently cached files for the given repo, without knowing
-     * the cachebuster token up front. The @cached() decorator on
-     * IRepository.fetch calls delete(repoName) before every write, so there is
-     * at most one token subdirectory under <repoName>/ at any time.
-     * Returns an empty map if the repo has never been fetched
-     * (i.e. no full build has run yet).
-     */
-    static async readLatest(repoName) {
-        if (!this.isValid(repoName, "repoName")) {
-            throw new Error(`Cache read requires 'repoName' to be provided`);
+    static async read(resource) {
+        const directory = this.getTempDir(resource.appName, await resource.token);
+        if (!await this.hasDirectory(resource)) {
+            log.verbose(`No cache directory '${directory}' found`);
+            return new Map();
         }
-        const repoDir = this.getTempDir(repoName);
-        if (!fs.existsSync(repoDir)) {
-            throw new Error(`No cache found for '${repoName}'. Run a full build first.`);
+        return ResourceUtil.byGlob(directory, "**/*");
+    }
+    static async write(resource, files) {
+        const token = await resource.token;
+        if (resource.appName == null || token == null) {
+            log.verbose(`No 'appName' or 'token' provided, skipping cache write`);
+            return;
         }
-        const [tokenDir] = await fsPromises.readdir(repoDir);
-        if (!tokenDir) {
-            throw new Error(`Cache directory for '${repoName}' is empty. Run a full build first.`);
+        if (!resource.keepAppNameDir) {
+            this.delete(resource.appName);
         }
-        return ResourceUtil.byGlob(path.join(repoDir, tokenDir), "**/*");
-    }
-    static async write(repoName, token, files) {
-        this.delete(repoName);
-        if (this.isValid(repoName, "repoName") && this.isValid(token, "token")) {
-            await ResourceUtil.write(this.getTempDir(repoName, token), files);
+        else {
+            this.delete(resource.appName, token);
         }
+        await ResourceUtil.write(this.getTempDir(resource.appName, token), files);
     }
-    static isValid(value, name) {
-        if (value == null || value === "") {
-            log.warn(`No '${name}' provided, skipping cache write`);
-            return false;
-        }
-        return true;
+    static mergedResource(reference) {
+        return { appName: reference, token: Promise.resolve(this.MERGED_DIR), keepAppNameDir: true };
     }
     /**
      * Clears cached files by repo name and token
@@ -91,14 +79,14 @@ export function cached() {
         const originalValue = descriptor.value;
         descriptor.value = async function (...args) {
             const cachedResource = args[0];
-            const { appName, cacheBusterToken: cachebusterToken } = cachedResource;
-            const token = await cachebusterToken;
-            let files = await CacheHolder.read(appName, token);
+            let files = await CacheHolder.read(cachedResource);
+            const appName = cachedResource.appName;
+            const token = await cachedResource.token;
             CacheHolder.clearOutdatedExcept(appName);
             if (files.size === 0) {
                 log.verbose(`No cache for repo '${appName}' with token '${token}'. Fetching from repository.`);
                 files = await originalValue.apply(this, args);
-                await CacheHolder.write(appName, token, files);
+                await CacheHolder.write(cachedResource, files);
             }
             else {
                 log.verbose(`Using cached files for repo '${appName}' with token '${token}'.`);

package/dist/cache/cachedResource.d.ts

@@ -1,4 +1,5 @@
 export default interface ICachedResource {
     appName: string;
-    cacheBusterToken: Promise<string>;
+    token: Promise<string>;
+    keepAppNameDir?: boolean;
 }

package/dist/index.d.ts

@@ -5,11 +5,10 @@ import { ITaskParameters } from "./model/types.js";
 declare const _default: ({ workspace, options, taskUtil }: ITaskParameters) => Promise<ReadonlyMap<string, Buffer<ArrayBufferLike>>>;
 export default _default;
 /**
- * Preview-time entry point (CF only). Produces the same manifest.json a
- * full build would produce, without going to the HTML5 Repo.
- * Precondition is a full build must have run at least once so the base app
- * files are cached by the @cached() decorator on HTML5Repository.fetch. If
- * the cache is empty, this throws with a message directing the user to run
- * a full build first.
+ * Produces the manifest.json a full build would produce, without a full UI5 build.
  */
 export declare function previewManifest({ workspace, options }: ITaskParameters): Promise<any>;
+/**
+ * Downloads the base app and all resources along the app-variant hierarchy and writes the merged files to `outputDir`.
+ */
+export declare function downloadAppResources({ workspace, options }: ITaskParameters, outputDir: string): Promise<void>;

package/dist/index.js

@@ -1,7 +1,10 @@
 import * as dotenv from "dotenv";
-import { bufferToString, getReferences, logBuilderVersion } from "./util/commonUtil.js";
+import { bufferToJson, logBuilderVersion } from "./util/commonUtil.js";
 import AppVariant from "./appVariant.js";
 import BaseApp from "./baseApp.js";
+import CacheHolder from "./cache/cacheHolder.js";
+import ResourceUtil from "./util/resourceUtil.js";
+import ReferencesBuilder from "./util/referencesBuilder.js";
 import { initialize } from "./landscapeConfiguration.js";
 /**
  * Creates an appVariant bundle from the provided resources.
@@ -14,51 +17,55 @@ export default async ({ workspace, options, taskUtil }) => {
     };
     dotenv.config();
     logBuilderVersion();
-    const { repository, adapter } = await initialize(options.configuration);
+    const { adapter, repository } = await initialize(options.configuration);
     const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
-    const setupCommandChain = adapter.createSetupCommandChain(adaptationProject.reference, repository);
-    await setupCommandChain.execute();
-    const appVariantIdHierarchy = await repository.getAppVariantIdHierarchy(adaptationProject.reference);
-    if (appVariantIdHierarchy.length === 0) {
-        throw new Error(`No app variant found for reference ${adaptationProject.reference}`);
-    }
-    // appVariantIdHierarchy contains original application on bottom and the
-    // latest app variant on top. We reverse the list to process original
-    // application first and then app variants in chronological order.
-    const reversedHierarchy = appVariantIdHierarchy.toReversed();
-    const fetchFilesPromises = reversedHierarchy.map(variant => repository.fetch(variant));
-    const appVariants = new Array();
-    const adapt = async (baseFiles, appVariant) => {
-        appVariants.push(appVariant);
-        const baseApp = BaseApp.fromFiles(baseFiles);
-        return adapter.createAdaptCommandChain(baseApp, appVariant).execute();
-    };
-    let files = await fetchFilesPromises.shift(); // original app files
-    for (const appVariantFilesPromise of fetchFilesPromises) {
-        const appVariantFiles = await appVariantFilesPromise;
-        files = await adapt(files, AppVariant.fromFiles(appVariantFiles));
-    }
-    files = await adapt(files, adaptationProject);
-    const references = getReferences(appVariants, adaptationProject.id);
+    const { files: baseFiles } = await foldBaseHierarchy(adapter, repository, adaptationProject.reference);
+    await CacheHolder.write(CacheHolder.mergedResource(adaptationProject.reference), new Map(baseFiles));
+    const files = await adapter.createAdaptCommandChain(baseFiles, adaptationProject).execute();
+    const references = new ReferencesBuilder()
+        .addReferences(files, adaptationProject.id)
+        .build();
     return adapter.createPostCommandChain(references, adaptationProject, ui5BuilderTools).execute(files);
 };
 /**
- * Preview-time entry point (CF only). Produces the same manifest.json a
- * full build would produce, without going to the HTML5 Repo.
- * Precondition is a full build must have run at least once so the base app
- * files are cached by the @cached() decorator on HTML5Repository.fetch. If
- * the cache is empty, this throws with a message directing the user to run
- * a full build first.
+ * Produces the manifest.json a full build would produce, without a full UI5 build.
  */
 export async function previewManifest({ workspace, options }) {
-    const { repository, adapter } = await initialize(options.configuration, { useCacheRepository: true });
+    const { adapter, repository } = await initialize(options.configuration, { useCache: true });
+    const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
+    const { files: baseFiles } = await foldBaseHierarchy(adapter, repository, adaptationProject.reference);
+    await CacheHolder.write(CacheHolder.mergedResource(adaptationProject.reference), new Map(baseFiles));
+    const baseApp = BaseApp.fromFiles(baseFiles);
+    const references = new ReferencesBuilder()
+        .addReference(adaptationProject.reference, adaptationProject.id)
+        .addReferences(baseFiles, adaptationProject.id)
+        .build();
+    const files = new Map(baseFiles);
+    await adapter.createManifestPreviewCommandChain(baseApp, adaptationProject, references).execute(files, "manifest.json");
+    return bufferToJson(files.get("manifest.json"));
+}
+/**
+ * Downloads the base app and all resources along the app-variant hierarchy and writes the merged files to `outputDir`.
+ */
+export async function downloadAppResources({ workspace, options }, outputDir) {
+    const { adapter, repository } = await initialize(options.configuration);
     const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
-    const [baseAppResource] = await repository.getAppVariantIdHierarchy(adaptationProject.reference);
-    const cachedBaseAppFiles = await repository.fetch(baseAppResource);
-    const baseApp = BaseApp.fromFiles(cachedBaseAppFiles);
-    const files = new Map(cachedBaseAppFiles);
-    const manifestPreviewCommandChain = adapter.createManifestPreviewCommandChain(baseApp, adaptationProject);
-    await manifestPreviewCommandChain.execute(files, "manifest.json");
-    return JSON.parse(bufferToString(files.get("manifest.json")));
+    const { files } = await foldBaseHierarchy(adapter, repository, adaptationProject.reference);
+    await ResourceUtil.write(outputDir, new Map(files));
+}
+async function foldBaseHierarchy(adapter, repository, reference) {
+    await adapter.createSetupCommandChain(reference, repository).execute();
+    const hierarchy = await repository.getAppVariantIdHierarchy(reference);
+    if (hierarchy.length === 0) {
+        throw new Error(`No app variant found for reference ${reference}`);
+    }
+    const fetchFilesPromises = hierarchy.toReversed()
+        .map(variant => repository.fetch(variant));
+    let files = await fetchFilesPromises.shift(); // original base app files
+    for (const filesPromise of fetchFilesPromises) {
+        const appVariant = AppVariant.fromFiles(await filesPromise);
+        files = await adapter.createAdaptCommandChain(files, appVariant).execute();
+    }
+    return { files };
 }
 //# sourceMappingURL=index.js.map

package/dist/landscapeConfiguration.d.ts

@@ -1,9 +1,9 @@
-import { IConfiguration, IInitializeOptions } from "./model/types.js";
+import { IConfiguration } from "./model/types.js";
 import { IAdapter } from "./adapters/adapter.js";
 import IRepository from "./repositories/repository.js";
-import IAnnotationManager from "./annotations/annotationManager.js";
-export declare function initialize(configuration: IConfiguration, options?: IInitializeOptions): Promise<{
+export declare function initialize(configuration: IConfiguration, options?: {
+    useCache?: boolean;
+}): Promise<{
     adapter: IAdapter;
     repository: IRepository;
-    annotationManager: IAnnotationManager;
 }>;

package/dist/landscapeConfiguration.js

@@ -8,12 +8,16 @@ const log = getLogger("@ui5/task-adaptation::LandscapeConfiguration");
 export async function initialize(configuration, options = {}) {
     const type = await getTypeByConfiguration(configuration);
     const enhancedConfig = { ...configuration, type };
-    const repository = await getRepository(enhancedConfig, options);
+    let repository = await getRepository(enhancedConfig);
     const annotationManager = await getAnnotationManager(enhancedConfig, repository);
+    if (options.useCache) {
+        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
+        repository = new CacheRepository(repository);
+    }
+    const adapter = await getAdapter(enhancedConfig, annotationManager);
     return {
-        adapter: await getAdapter(enhancedConfig, annotationManager),
-        repository,
-        annotationManager
+        adapter,
+        repository
     };
 }
 async function getTypeByConfiguration(configuration) {
@@ -38,62 +42,62 @@ async function getTypeByConfiguration(configuration) {
         throw new Error("'type' should be specified in ui5.yaml configuration: 'cf' or 'abap'");
     }
 }
-async function getAdapter(configuration, annotationManager) {
-    if (isPreview()) {
-        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
-        return new PreviewAdapter(configuration);
-    }
-    switch (configuration.type) {
-        case "abap": {
+const LANDSCAPE_FACTORIES = {
+    abap: {
+        adapter: async (_configuration, annotationManager) => {
             const { default: AbapAdapter } = await import("./adapters/abapAdapter.js");
             return new AbapAdapter(annotationManager);
-        }
-        case "cf": {
+        },
+        repository: async (configuration) => {
+            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
+            return new AbapRepository(configuration);
+        },
+        annotationManager: async (configuration, repository) => {
+            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
+            return new AbapAnnotationManager(configuration, repository);
+        },
+    },
+    cf: {
+        adapter: async (configuration) => {
             const { default: CFAdapter } = await import("./adapters/cfAdapter.js");
             return new CFAdapter(configuration);
-        }
-        default:
-            throw new Error(`No adapter found for the given configuration type '${configuration.type}'`);
+        },
+        repository: async (configuration) => {
+            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
+            return new HTML5Repository(configuration);
+        },
+        annotationManager: async () => {
+            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
+            return new CFAnnotationManager();
+        },
+    },
+};
+function landscapeFactory(configuration) {
+    const factory = LANDSCAPE_FACTORIES[configuration.type];
+    if (!factory) {
+        throw new Error(`No landscape factory found for the given configuration type '${configuration.type}'`);
     }
+    return factory;
 }
-async function getRepository(configuration, options) {
-    if (options.useCacheRepository) {
-        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
-        return new CacheRepository(configuration);
+async function getAdapter(configuration, annotationManager) {
+    if (isPreview()) {
+        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
+        return new PreviewAdapter(configuration);
     }
+    return landscapeFactory(configuration).adapter(configuration, annotationManager);
+}
+async function getRepository(configuration) {
     if (isLocal()) {
         const { default: LocalRepository } = await import("./repositories/localRepository.js");
         return new LocalRepository();
     }
-    switch (configuration.type) {
-        case "abap": {
-            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
-            return new AbapRepository(configuration);
-        }
-        case "cf": {
-            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
-            return new HTML5Repository(configuration);
-        }
-        default:
-            throw new Error(`No repository found for the given configuration type '${configuration.type}'`);
-    }
+    return landscapeFactory(configuration).repository(configuration);
 }
 async function getAnnotationManager(configuration, repository) {
     if (isLocal()) {
         return new LocalAnnotationManager();
     }
-    switch (configuration.type) {
-        case "abap": {
-            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
-            return new AbapAnnotationManager(configuration, repository);
-        }
-        case "cf": {
-            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
-            return new CFAnnotationManager();
-        }
-        default:
-            throw new Error(`No annotation manager found for the given configuration type '${configuration.type}'`);
-    }
+    return landscapeFactory(configuration).annotationManager(configuration, repository);
 }
 function isLocal() {
     return process.env.ADP_BUILDER_MODE === "local";

package/dist/model/configuration.d.ts

@@ -12,7 +12,6 @@ export interface IConfiguration {
     languages?: any[] | undefined;
     enableAnnotationCache?: boolean;
     enableBetaFeatures?: boolean;
-    writeTempFiles?: any;
     target?: AbapTarget & IAbapTargetMeta;
     serviceInstanceName?: string;
 }

package/dist/model/types.d.ts

@@ -132,6 +132,3 @@ export type ServiceCredentials = {
 };
 export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, Buffer>>>;
 export { IConfiguration };
-export interface IInitializeOptions {
-    useCacheRepository?: boolean;
-}

package/dist/repositories/abapRepository.d.ts

@@ -9,7 +9,7 @@ export default class AbapRepository implements IRepository {
     constructor(configuration: IConfiguration, abapProvider?: AbapProvider);
     getAppVariantIdHierarchy(id: string): Promise<IAbapResource[]>;
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
+    downloadAnnotationFile(uri: string): Promise<any>;
     getMetadata(id: string): Promise<IMetadata>;
     fetch(resource: IAbapResource): Promise<Map<string, Buffer>>;
 }

package/dist/repositories/abapRepository.js

@@ -37,14 +37,14 @@ export default class AbapRepository {
             const hierarchy = JSON.parse(response.data)?.appVariantIdHierarchy;
             return hierarchy.map(item => ({
                 appName: item.repoName,
-                cacheBusterToken: Promise.resolve(item.cachebusterToken)
+                token: Promise.resolve(item.cachebusterToken)
             }));
         }
         else if (this.configuration.appName) {
             // Fallback to old API on old ABAP backend or CF for backward compatibility
             return [{
                     appName: this.configuration.appName,
-                    cacheBusterToken: this.getMetadata(id).then(metadata => metadata.changedOn),
+                    token: this.getMetadata(id).then(metadata => metadata.changedOn),
                 }];
         }
         throw new Error(`App variant id hierarchy for app id '${id}' is not provided`);
@@ -59,7 +59,7 @@ export default class AbapRepository {
         const response = await provider.get(uri, {
             headers: REQUEST_OPTIONS_XML.headers
         });
-        return new Map([["annotation.xml", response.data]]);
+        return response.data;
     }
     async getMetadata(id) {
         const provider = await this.abapProvider.get(this.configuration);