@sap/artifact-management-types 1.44.0 → 1.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/artifact-management-types",
-  "version": "1.44.0",
+  "version": "1.45.1",
   "description": "Type signatures for artifact management",
   "types": "./src/index.d.ts",
   "main": "./src/index.d.ts",
@@ -10,7 +10,7 @@
     "pack": "npm run modify-types-import && npm pack"
   },
   "dependencies": {
-    "@sap/artifact-management-base-types": "1.44.0"
+    "@sap/artifact-management-base-types": "1.45.1"
   },
   "devDependencies": {
     "gulp": "4.0.2"

package/src/plugins/abap/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@sap/artifact-management-base-types';
+declare const AbapPlugin: Plugin;
+export default AbapPlugin;

package/src/plugins/abap/readers/AbapModuleReader.d.ts

@@ -0,0 +1,33 @@
+import { ProjectFileSystem, Item, ModuleType, ModuleData, ProjectEntityReaderReadOptions, KeyIn, ItemDetailInfoOptions, ProjectContext } from '@sap/artifact-management-base-types';
+import { ItemFilter } from '@sap/artifact-management-base/types';
+import CapModuleReader from '../../cap/readers/CapModuleReader';
+interface AbapItemReaderContext {
+    withDetailInfo?: boolean;
+    filter?: ItemFilter;
+}
+export default class AbapModuleReader extends CapModuleReader {
+    getType(): KeyIn<typeof ModuleType>;
+    matchConditions: {
+        requiredFilePatterns: string[];
+    };
+    itemTags: string[];
+    tags: string[];
+    itemReaders: {
+        matchConditions: {
+            requiredFilePatterns: string[];
+        };
+        types: string[];
+        tags: string[];
+        read: (options: ProjectEntityReaderReadOptions) => Promise<Item[]>;
+        detailInfo: (fs: ProjectFileSystem, ref: string, options?: ItemDetailInfoOptions | undefined) => Promise<Item | undefined>;
+    }[];
+    read({ fs }: {
+        fs: ProjectFileSystem;
+    }): Promise<ModuleData | undefined>;
+    prepareItemReaderContext(fs: ProjectFileSystem, context: ProjectContext): Promise<AbapItemReaderContext | undefined>;
+    private provideFromCsn;
+    private getAbapServicesItems;
+    private createItems;
+    private processCsnFile;
+}
+export {};

package/src/plugins/abap/readers/AbapProjectReader.d.ts

@@ -0,0 +1,9 @@
+import { DetectionMechanism, KeyIn, ProjectData, ProjectReader, ProjectReaderOptions, ProjectType } from '@sap/artifact-management-base-types';
+export default class AbapProjectReader extends ProjectReader {
+    constructor();
+    getType(): KeyIn<typeof ProjectType>;
+    getDetectionMechanism(): DetectionMechanism;
+    moduleSearchPattern(): Promise<string[]>;
+    tags: string[];
+    read({ fs, matchedFiles }: ProjectReaderOptions): Promise<ProjectData | undefined>;
+}

package/src/plugins/abap/utils/AbapReaderUtil.d.ts

@@ -0,0 +1,22 @@
+import { CDSDefinition, Item, LinkType } from '@sap/artifact-management-base-types';
+export interface EntityRefInfo {
+    ref: string;
+    path: string;
+    name: string;
+    prefixRef: string;
+}
+export interface DependItem {
+    item: Item;
+    linkType: LinkType;
+}
+export declare function fillAbapServiceItemInfo(serviceItem: Item, service: CDSDefinition): Item;
+export declare function filterMatchedFiles(matchedFiles: Record<string, string[]>, csnFilter?: string[]): string[];
+export declare function fillServices(services: CDSDefinition[], csnFile: string, itemTags: string[], items: Map<string, Item>): void;
+export declare function fillEntities(entities: CDSDefinition[], csnFile: string, itemTags: string[], items: Map<string, Item>): void;
+export declare function processEntityItems(entities: CDSDefinition[], items: Map<string, Item>): void;
+export declare function processDependencies(entity: CDSDefinition, entityItem: Item, items: Map<string, Item>, prefixRef: string): void;
+export declare function addLinksToEntity(entityItem: Item, dependItems: DependItem[]): void;
+export declare function fillCompositions(entity: CDSDefinition, entityItem: Item, items: Map<string, Item>): void;
+export declare function processAssociations(entity: CDSDefinition, entityItem: Item): void;
+export declare function getAbapEntityRef(name: string): EntityRefInfo;
+export declare function getEntityTypeByPath(path: string): string;

package/src/plugins/abap/utils/FioriUiForAbapUtil.d.ts

@@ -0,0 +1,23 @@
+import { Item, ProjectData, ProjectFileSystem, VSCodeFileSystem } from '@sap/artifact-management-base-types';
+interface AppGenInfoItem {
+    serviceNameCsn: string;
+    csnName: string;
+    packageUri: string;
+}
+interface AppGenInfo {
+    abapCSN: AppGenInfoItem[];
+}
+interface AppGenInfoFile {
+    externalParameters: AppGenInfo;
+}
+export declare type ServiceItemsMap = Map<string, Item[]>;
+export declare function isAppGenInfoItem(obj: any): obj is AppGenInfoItem;
+export declare function filterValidAppGenInfoItems(items: any[]): AppGenInfoItem[];
+export declare function parseAppGenInfoContent(fileContent: AppGenInfoFile): AppGenInfoFile;
+export declare function isFioriUiForAbap(fioriProjectPath: string): any;
+export declare function initFioriUiItem(projectInfo: ProjectData): Item;
+export declare function updateUiItem(UiItem: Item, serviceItem: Item): void;
+export declare function updateUiItems(appGenInfoFile: AppGenInfoFile, serviceCsnsMap: ServiceItemsMap, projectFs: ProjectFileSystem | VSCodeFileSystem, fioriUiItem: Item): void;
+export declare function createUiItemsForAbap(projectInfo: ProjectData, serviceItemsMap: ServiceItemsMap, projectFs: ProjectFileSystem | VSCodeFileSystem): Item | undefined;
+export declare function fetchUiAndUpdateUiProject(projectFs: ProjectFileSystem, serviceItemsMap: ServiceItemsMap): Promise<Item[]>;
+export {};

package/src/plugins/cap/readers/CapModuleReader.d.ts

@@ -37,7 +37,7 @@ export default class CapModuleReader extends ModuleReader {
     provideFromCds({ fs, matchedFiles, context }: ProjectEntityReaderReadOptions): Promise<Item[]>;
     detailInfo(fs: ProjectFileSystem, ref: string, options?: ItemDetailInfoOptions): Promise<Item | undefined>;
     readCSV({ fs, matchedFiles }: ProjectEntityReaderReadOptions): Promise<Item[]>;
-    readApplicationLogic({ fs, matchedFiles }: ProjectEntityReaderReadOptions): Promise<Item[]>;
+    readApplicationLogic({ fs, matchedFiles, context }: ProjectEntityReaderReadOptions): Promise<Item[]>;
     private addUnboundFunctionItems;
     private addUnboundActionItems;
     private addEventItems;

package/src/plugins/cap/util/CapLogicUtil.d.ts

@@ -0,0 +1,42 @@
+import * as t from '@babel/types';
+export declare type PhaseType = 'before' | 'on' | 'after';
+export declare const phases: string[];
+export declare const EVENT_UNDEFINED = "__undefined__";
+export declare const DEFAULT_INDENT = 4;
+export interface LogicTarget {
+    service: string;
+    entity?: string;
+    action?: string;
+    externalService?: string;
+    externalServiceEvent?: string;
+}
+export interface Event {
+    name: string;
+    phase: PhaseType;
+}
+export interface ApplicationLogic {
+    name: string;
+    displayName?: string;
+    legacy?: boolean;
+    compatible?: boolean;
+    description?: string;
+    target: LogicTarget;
+    draft?: boolean;
+    code?: string;
+    events: Event[];
+}
+export declare const rectifyEvent: (name: string) => string;
+export default class ServiceScript {
+    private readonly serviceContent;
+    private raw;
+    constructor(serviceContent: string);
+    private tryParseScript;
+    private getServices;
+    list(): Promise<ApplicationLogic[]>;
+}
+interface ServiceDefinition {
+    name?: string;
+    node: t.Node;
+}
+export declare function parseServiceDefinitions(ast: t.File | t.Program): ServiceDefinition[];
+export {};

package/src/plugins/cap/util/ItemUtil.d.ts

@@ -15,6 +15,7 @@ export default class ItemUtil {
     static addLink(entity: Item, target: any, linkType: LinkType, serviceRefs: {
         [key: string]: string;
     }): void;
+    static addCapLinksToAppLogicItem(fs: ProjectFileSystem, file: string, capApi: CapApi, items: Item[], tags: any[]): Promise<void>;
     static addLinksToAppLogicItem(fs: ProjectFileSystem, file: string, capApi: CapApi, logicItem: Item): Promise<void>;
     static addLinksToJavaAppLogicItem(fs: ProjectFileSystem, file: string, capApi: CapApi, logicItem: Item): Promise<void>;
     private static addLinksToAppLogicItemWithEntity;

package/src/plugins/cap/util/PathUtil.d.ts

@@ -6,4 +6,5 @@ export default class PathUtil {
      */
     static getLocationForWindows(path: string, rootPath: string): string;
     static getExternalServiceInfo(fs: ProjectFileSystem): Promise<Set<any>>;
+    static isLCAPProject(fs: ProjectFileSystem): Promise<boolean>;
 }

package/src/project-api/ProjectEntityInstance.d.ts

@@ -29,9 +29,10 @@ export default class ProjectEntityInstance<T> extends EventEmitter {
      * of "getChildCache()".
      *
      */
-    protected getChildCached<Child>({ name, load }: {
+    protected getChildCached<Child>({ name, load, extraKey }: {
         name: string;
         load: () => Promise<Child>;
+        extraKey?: string;
     }): Promise<Child>;
     /**
      * Get data of an entity

package/src/project-api/ProjectModulesInstance.d.ts

@@ -16,10 +16,13 @@ export default class ProjectModulesInstance extends ProjectEntityInstance<string
     loadModuleDirectories(): Promise<LoadResult<string[]>>;
     loadModuleInstances(directoryPaths: string[]): Promise<ModuleInstance[]>;
     getModules(): Promise<ModuleData[]>;
-    readDeep(withDetailInfo?: boolean): Promise<Project | undefined>;
+    readDeep(withDetailInfo?: boolean, filter?: ItemFilter): Promise<Project | undefined>;
     getModuleDirectories(): Promise<string[]>;
     getModuleInstances(): Promise<ModuleInstance[]>;
     readItems(filter?: ItemFilter, withDetailInfo?: boolean): Promise<Item[]>;
+    private filterMatching;
+    private assembleItemsMap;
+    private addReverseLinks;
     private getItemsFilteredByTags;
     detailInfo(type: KeyIn<typeof ItemType>, ref: string, entityPath?: string, options?: ItemDetailInfoOptions): Promise<Item | undefined>;
 }

package/src/project-api/VSCodeWorkspace.d.ts

@@ -1,31 +1,13 @@
-/// <reference types="node" />
-import { FSWatcher } from 'fs';
-import { Event, Uri, WorkspaceFolder, WorkspaceFoldersChangeEvent, FileSystem } from 'vscode';
-import { IPluginManager, KeyIn, Tag } from '@sap/artifact-management-base-types';
+import { IPluginManager, KeyIn, Tag, VSCodeApi } from '@sap/artifact-management-base-types';
 import ProjectApi from './ProjectApi';
 import WorkspaceApi from './WorkspaceApi';
-export interface VSCodeWorksapceLike {
-    workspaceFolders: readonly WorkspaceFolder[] | undefined;
-    onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>;
-    workspaceFile: Uri | undefined;
-    fs: FileSystem;
-}
-export interface VSCodeUriLike {
-    file(path: string): Uri;
-}
-export interface VSCodeLike {
-    Uri: VSCodeUriLike;
-    workspace: VSCodeWorksapceLike;
-}
 export default class VSCodeWorkspace implements WorkspaceApi {
-    workspaceFolders: readonly WorkspaceFolder[] | undefined;
-    workspaceWatcher?: FSWatcher;
     workspaceChangeHandler?: (event: string, folders: any[]) => void;
     private watch?;
     private readModuleAsProject;
     private vscode;
     private readers;
-    constructor(vscode: VSCodeLike, readModuleAsProject: boolean);
+    constructor(vscodeParam: VSCodeApi, readModuleAsProject: boolean);
     private getSubFolders;
     getProjects(tag?: KeyIn<typeof Tag>, path?: string, shallow?: boolean): Promise<ProjectApi[]>;
     getProject(path: string, useHeadlessGenerator?: boolean): Promise<ProjectApi>;
@@ -38,4 +20,5 @@ export default class VSCodeWorkspace implements WorkspaceApi {
     onWorkspaceChanged(handler: (event: string, folders: string[]) => void): void;
     private getRootPath;
     getPluginManager(): IPluginManager;
+    private resolvePath;
 }

package/src/project-api/WorkspaceImpl.d.ts

@@ -1,11 +1,9 @@
-import { IPluginManager, KeyIn, Tag } from '@sap/artifact-management-base-types';
+import { IPluginManager, KeyIn, Tag, VSCodeApi } from '@sap/artifact-management-base-types';
 import ProjectApi from './ProjectApi';
 import WorkspaceApi from './WorkspaceApi';
-import { VSCodeLike } from './VSCodeWorkspace';
-export { VSCodeLike };
 export default class WorkspaceImpl implements WorkspaceApi {
     private api;
-    constructor(pathOrWorkspace: string | VSCodeLike, readModuleAsProject?: boolean);
+    constructor(pathOrWorkspace: string | VSCodeApi, readModuleAsProject?: boolean);
     getProjects(tag?: KeyIn<typeof Tag>, path?: string, shallow?: boolean): Promise<ProjectApi[]>;
     getProject(path: string, useHeadlessGenerator?: boolean): Promise<ProjectApi>;
     getProjectUris(): Promise<string[]>;