@hahnpro/hpc-api 2025.2.15 → 2025.3.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @hahnpro/hpc-api
 
+## 2025.3.2
+
+### Patch Changes
+
+- Added asset::findOneExternal and asset::updateOneExternal to reflect changes to asset API
+- Updated some Mock Types to improve type-compliance between real and mock API classes
+- Added documentation on how to develop an asset synchronization script from external systems
+
+## 2025.3.1
+
+### Patch Changes
+
+- Updated dependencies to reduce vulnerabilities
+
+## 2025.3.0
+
+### Patch Changes
+
+- URL and method of the `asset::getEventLevelOverride` and `asset:updateEventCausesAsset` have been changed.
+
 ## 2025.2.15
 
 ### Major Changes

package/README.md

@@ -135,7 +135,7 @@ This example uses the [`pyjwt` library](https://pyjwt.readthedocs.io/en/stable/)
 </details>
 
 <details>
-  <summary markdown="span">Python</summary>
+  <summary markdown="span">Typescript</summary>
 
 Get user roles from JWT-Token.
 
@@ -483,24 +483,3 @@ await api.timeSeries.addValue('1234', value);
 ```
 
 </details>
-
-## 4. FAQ
-
-### 4.1. How to log messages from Python in a FlowFunction
-
-> this is just possible for _RPC_ style Python integration.
-
-In Typescript, you can register a listener for messages and `stderr` and pipe them to your `logger`.
-
-```typescript
-const script = this.runPyRpcScript(join(__dirname, 'my-awesome-script.py'));
-script.addListener('stderr', (data) => this.logger.error('py: ' + data));
-script.on('message', (data) => this.logger.debug('py: ' + data));
-```
-
-Then you can simply use print in python for logging
-
-```python
-  print("log the logging log")
-  print("this is an error", file=sys.stderr)
-```

package/asset-synchronization.md

@@ -0,0 +1,556 @@
+# Asset Synchronization Documentation
+
+This documentation describes the process for synchronizing assets and asset types with the Hahn PRO Cloud API, including synchronization using external keys.
+
+The fundamental approaches are useful in any language, but the examples here are in typescript. At the end you will have a
+complete script for synchronizing Assettypes and Assets, i.e. creating them if they don´t exist and updating existing ones.
+There are multiple approaches shown here, select the one that fits your use-case.
+
+## Overview
+
+The synchronization process follows two main steps:
+
+1. **Synchronize Asset Types**: Check and create asset types based on their names
+2. **Synchronize Assets**: Check and create assets based on their names or external keys using a similar process
+
+## Prerequisites
+
+- Access to Hahn PRO Cloud API
+- Valid authentication (JWT token)
+- Permissions to create asset types and assets
+
+## Synchronization Methods
+
+There are two approaches for asset synchronization:
+
+1. **Name-based synchronization**: Uses the asset name for duplicate detection
+2. **External key-based synchronization**: Uses the `externalKey` field for duplicate detection
+3. **Update mode**: Updates existing assets instead of skipping them
+
+## 1. Asset Type Synchronization
+
+### Process
+
+1. **Fetch existing asset types**: Load all current asset types
+2. **Name comparison**: For each asset type to be created, check if a type with the same name already exists
+3. **Check dependencies**: Ensure all parent types already exist
+4. **Create**: Create new asset types if they don't exist
+
+### TypeScript Implementation
+
+```typescript
+async function synchronizeAssetTypes(assetTypes: AssetType[], orgId: string): Promise<void> {
+  // Load all existing asset types
+  const existingTypes = await api.assetTypes.getMany();
+  const existingTypeNames = new Set(existingTypes.docs.map((type) => type.name));
+
+  // Map for name-to-ID mapping
+  const assetTypeNameIdMap = new Map<string, string>();
+
+  // Populate map with existing types
+  existingTypes.docs.forEach((type) => {
+    assetTypeNameIdMap.set(type.name, type.id);
+  });
+
+  // Process asset types (considering dependencies)
+  while (assetTypes.length > 0) {
+    const type = assetTypes.shift();
+
+    // Check if type already exists
+    if (existingTypeNames.has(type.name)) {
+      console.log(`Asset type '${type.name}' already exists - skipping`);
+      continue;
+    }
+
+    // Check if all parent types have been created
+    if (!(type.allowedParents || [])?.every((parent) => assetTypeNameIdMap.has(parent))) {
+      // Not all parent types exist -> requeue
+      assetTypes.push(type);
+      continue;
+    }
+
+    try {
+      // Create new asset type
+      const created = await api.assetTypes.addOne({
+        ...type,
+        allowedParents: (type.allowedParents || []).map((parent) => assetTypeNameIdMap.get(parent)),
+        readWritePermissions: [...type.readWritePermissions, orgId],
+      });
+
+      assetTypeNameIdMap.set(type.name, created.id);
+      console.log(`Asset type '${type.name}' created successfully`);
+    } catch (error) {
+      console.error(`Error creating asset type '${type.name}':`, error);
+      throw error;
+    }
+  }
+}
+```
+
+## 2. Asset Synchronization by Name (Create Only)
+
+### Process
+
+1. **Fetch existing assets**: Load all current assets
+2. **Name comparison**: For each asset to be created, check if an asset with the same name already exists
+3. **Check parent dependencies**: Ensure parent assets already exist
+4. **Type mapping**: Map asset type based on name
+5. **Create**: Create new assets if they don't exist
+
+### TypeScript Implementation
+
+```typescript
+async function synchronizeAssetsByName(assets: Asset[], orgId: string, updateExisting: boolean = false): Promise<void> {
+  // Load all existing assets
+  const existingAssets = await api.assets.getMany();
+  const existingAssetNames = new Map<string, string>(); // name -> id
+
+  // Map for name-to-ID mapping
+  const assetNameIdMap = new Map<string, string>();
+
+  // Populate map with existing assets
+  existingAssets.docs.forEach((asset) => {
+    assetNameIdMap.set(asset.name, asset.id);
+    existingAssetNames.set(asset.name, asset.id);
+  });
+
+  // Process assets (considering parent dependencies)
+  while (assets.length > 0) {
+    const asset = assets.shift();
+
+    // Check if asset already exists
+    if (existingAssetNames.has(asset.name)) {
+      if (updateExisting) {
+        try {
+          // Update existing asset
+          const existingId = existingAssetNames.get(asset.name);
+          const updated = await api.assets.updateOne(existingId, {
+            ...asset,
+            type: assetTypeNameIdMap.get(asset.type as string),
+            parent: assetNameIdMap.get(asset.parent),
+            readWritePermissions: [...asset.readWritePermissions, orgId],
+          });
+          console.log(`Updated existing asset '${asset.name}'`);
+          assetNameIdMap.set(asset.name, updated.id);
+        } catch (error) {
+          console.error(`Error updating asset '${asset.name}':`, error);
+          throw error;
+        }
+      } else {
+        console.log(`Asset '${asset.name}' already exists - skipping`);
+      }
+      continue;
+    }
+
+    // Check if parent asset exists (if defined)
+    if (asset.parent && !assetNameIdMap.has(asset.parent)) {
+      // Parent doesn't exist yet -> requeue
+      assets.push(asset);
+      continue;
+    }
+
+    // Check if asset type exists
+    if (!assetTypeNameIdMap.has(asset.type as string)) {
+      throw new Error(`Asset type '${asset.type}' not found`);
+    }
+
+    try {
+      // Create new asset
+      const created = await api.assets.addOne({
+        ...asset,
+        type: assetTypeNameIdMap.get(asset.type as string),
+        parent: assetNameIdMap.get(asset.parent),
+        readWritePermissions: [...asset.readWritePermissions, orgId],
+      });
+
+      assetNameIdMap.set(asset.name, created.id);
+      console.log(`Asset '${asset.name}' created successfully`);
+    } catch (error) {
+      console.error(`Error creating asset '${asset.name}':`, error);
+      throw error;
+    }
+  }
+}
+```
+
+## 3. Asset Synchronization by External Key
+
+When synchronizing assets from external systems, you can use the `externalKey` field to identify assets. This is particularly useful when the external system has its own unique identifiers.
+
+### Process
+
+1. **Check for existing assets by external key**: Use the external endpoints to find existing assets
+2. **Update or create**: Update existing assets or create new ones based on external key presence
+3. **Handle dependencies**: Ensure parent assets exist before creating child assets
+
+### TypeScript Implementation
+
+```typescript
+async function synchronizeAssetsByExternalKey(assets: Asset[], orgId: string): Promise<void> {
+  // Maps for tracking assets
+  const assetExternalKeyIdMap = new Map<string, string>();
+  const assetNameIdMap = new Map<string, string>();
+
+  // Process assets (considering parent dependencies)
+  while (assets.length > 0) {
+    const asset = assets.shift();
+
+    if (!asset.externalKey) {
+      throw new Error(`Asset '${asset.name}' missing externalKey for external synchronization`);
+    }
+
+    // Check if parent asset exists (if defined)
+    if (asset.parent && !assetNameIdMap.has(asset.parent) && !assetExternalKeyIdMap.has(asset.parent)) {
+      // Parent doesn't exist yet -> requeue
+      assets.push(asset);
+      continue;
+    }
+
+    // Check if asset type exists
+    if (!assetTypeNameIdMap.has(asset.type as string)) {
+      throw new Error(`Asset type '${asset.type}' not found`);
+    }
+
+    try {
+      // Try to find existing asset by external key
+      let existingAsset: Asset | null = null;
+      try {
+        existingAsset = await api.assets.findOneExternal(asset.externalKey);
+        console.log(`Found existing asset with external key '${asset.externalKey}'`);
+      } catch (error) {
+        // Asset doesn't exist yet - this is expected for new assets
+        console.log(`Asset with external key '${asset.externalKey}' not found - will create new`);
+      }
+
+      let resultAsset: Asset;
+
+      if (existingAsset) {
+        // Update existing asset using external key endpoint
+        resultAsset = await api.assets.updateOneExternal(asset.externalKey, {
+          ...asset,
+          type: assetTypeNameIdMap.get(asset.type as string),
+          parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+          readWritePermissions: [...asset.readWritePermissions, orgId],
+        });
+        console.log(`Updated asset with external key '${asset.externalKey}'`);
+      } else {
+        // Create new asset
+        resultAsset = await api.assets.addOne({
+          ...asset,
+          type: assetTypeNameIdMap.get(asset.type as string),
+          parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+          readWritePermissions: [...asset.readWritePermissions, orgId],
+        });
+        console.log(`Created new asset with external key '${asset.externalKey}'`);
+      }
+
+      // Update maps for dependency resolution
+      assetExternalKeyIdMap.set(asset.externalKey, resultAsset.id);
+      assetNameIdMap.set(asset.name, resultAsset.id);
+    } catch (error) {
+      console.error(`Error processing asset with external key '${asset.externalKey}':`, error);
+      throw error;
+    }
+  }
+}
+```
+
+## 4. Mixed Synchronization (Name and External Key)
+
+For scenarios where some assets have external keys and others don't, you can use a mixed approach:
+
+```typescript
+async function synchronizeAssetsMixed(assets: Asset[], orgId: string, updateExisting: boolean = false): Promise<void> {
+  // Load all existing assets for name-based lookup
+  const existingAssets = await api.assets.getMany();
+  const existingAssetNames = new Map<string, string>(); // name -> id
+
+  // Maps for tracking assets
+  const assetExternalKeyIdMap = new Map<string, string>();
+  const assetNameIdMap = new Map<string, string>();
+
+  // Populate map with existing assets
+  existingAssets.docs.forEach((asset) => {
+    assetNameIdMap.set(asset.name, asset.id);
+    existingAssetNames.set(asset.name, asset.id);
+    if (asset.externalKey) {
+      assetExternalKeyIdMap.set(asset.externalKey, asset.id);
+    }
+  });
+
+  // Process assets (considering parent dependencies)
+  while (assets.length > 0) {
+    const asset = assets.shift();
+
+    // Determine identification method
+    const useExternalKey = !!asset.externalKey;
+    const identifier = useExternalKey ? asset.externalKey : asset.name;
+
+    // Check if parent asset exists (if defined)
+    if (asset.parent && !assetNameIdMap.has(asset.parent) && !assetExternalKeyIdMap.has(asset.parent)) {
+      // Parent doesn't exist yet -> requeue
+      assets.push(asset);
+      continue;
+    }
+
+    // Check if asset type exists
+    if (!assetTypeNameIdMap.has(asset.type as string)) {
+      throw new Error(`Asset type '${asset.type}' not found`);
+    }
+
+    try {
+      let resultAsset: Asset;
+      let assetExists = false;
+
+      if (useExternalKey) {
+        // Try to find existing asset by external key
+        try {
+          await api.assets.findOneExternal(asset.externalKey);
+          assetExists = true;
+        } catch (error) {
+          assetExists = false;
+        }
+
+        if (assetExists) {
+          // Update existing asset using external key endpoint
+          resultAsset = await api.assets.updateOneExternal(asset.externalKey, {
+            ...asset,
+            type: assetTypeNameIdMap.get(asset.type as string),
+            parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+            readWritePermissions: [...asset.readWritePermissions, orgId],
+          });
+          console.log(`Updated asset with external key '${asset.externalKey}'`);
+        } else {
+          // Create new asset
+          resultAsset = await api.assets.addOne({
+            ...asset,
+            type: assetTypeNameIdMap.get(asset.type as string),
+            parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+            readWritePermissions: [...asset.readWritePermissions, orgId],
+          });
+          console.log(`Created new asset with external key '${asset.externalKey}'`);
+        }
+        assetExternalKeyIdMap.set(asset.externalKey, resultAsset.id);
+      } else {
+        // Name-based approach
+        assetExists = existingAssetNames.has(asset.name);
+
+        if (assetExists && updateExisting) {
+          // Update existing asset using standard endpoint
+          const existingId = existingAssetNames.get(asset.name);
+          resultAsset = await api.assets.updateOne(existingId, {
+            ...asset,
+            type: assetTypeNameIdMap.get(asset.type as string),
+            parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+            readWritePermissions: [...asset.readWritePermissions, orgId],
+          });
+          console.log(`Updated existing asset '${asset.name}'`);
+        } else if (assetExists && !updateExisting) {
+          console.log(`Asset '${asset.name}' already exists - skipping`);
+          continue;
+        } else {
+          // Create new asset using standard method
+          resultAsset = await api.assets.addOne({
+            ...asset,
+            type: assetTypeNameIdMap.get(asset.type as string),
+            parent: assetNameIdMap.get(asset.parent) || assetExternalKeyIdMap.get(asset.parent),
+            readWritePermissions: [...asset.readWritePermissions, orgId],
+          });
+          console.log(`Created asset '${asset.name}'`);
+        }
+      }
+
+      assetNameIdMap.set(asset.name, resultAsset.id);
+    } catch (error) {
+      console.error(`Error processing asset '${identifier}':`, error);
+      throw error;
+    }
+  }
+}
+```
+
+## 5. Complete Synchronization Function
+
+```typescript
+interface SynchronizationOptions {
+  useExternalKeys?: boolean;
+  updateExisting?: boolean;
+  mixedMode?: boolean;
+}
+
+async function synchronizeAssetsComplete(
+  assetTypes: AssetType[],
+  assets: Asset[],
+  orgId: string,
+  options: SynchronizationOptions = {},
+): Promise<void> {
+  const { useExternalKeys = false, updateExisting = false, mixedMode = false } = options;
+
+  console.log('Starting asset synchronization...');
+  console.log(`Options: External Keys: ${useExternalKeys}, Update Existing: ${updateExisting}, Mixed Mode: ${mixedMode}`);
+
+  try {
+    // Step 1: Synchronize asset types
+    console.log('Synchronizing asset types...');
+    await synchronizeAssetTypes([...assetTypes], orgId);
+
+    // Step 2: Synchronize assets
+    console.log('Synchronizing assets...');
+    if (mixedMode) {
+      await synchronizeAssetsMixed([...assets], orgId, updateExisting);
+    } else if (useExternalKeys) {
+      await synchronizeAssetsByExternalKey([...assets], orgId);
+    } else {
+      await synchronizeAssetsByName([...assets], orgId, updateExisting);
+    }
+
+    console.log('Asset synchronization completed successfully!');
+  } catch (error) {
+    console.error('Error during asset synchronization:', error);
+    throw error;
+  }
+}
+```
+
+## 6. Usage Examples
+
+### Create Only (Skip Existing)
+
+```typescript
+import { readFileSync } from 'fs';
+
+import { API, Asset, AssetType } from '@hahnpro/hpc-api';
+
+// Initialize API
+const api = new API();
+
+// Load data from JSON files
+const assetTypes = JSON.parse(readFileSync('assetTypes.json', 'utf-8')) as AssetType[];
+const assets = JSON.parse(readFileSync('assets.json', 'utf-8')) as Asset[];
+
+// Organization ID
+const orgId = 'your-organization-id';
+
+// Execute synchronization - create only
+await synchronizeAssetsComplete(assetTypes, assets, orgId, {
+  updateExisting: false,
+});
+```
+
+### Update Existing Assets by Name
+
+```typescript
+// Execute synchronization - update existing assets by name
+await synchronizeAssetsComplete(assetTypes, assets, orgId, {
+  updateExisting: true,
+});
+```
+
+### Using External Key-based Synchronization
+
+```typescript
+// Execute synchronization using external keys (always updates existing)
+await synchronizeAssetsComplete(assetTypes, assets, orgId, {
+  useExternalKeys: true,
+});
+```
+
+### Mixed Mode with Updates
+
+```typescript
+// Execute mixed mode synchronization with updates
+await synchronizeAssetsComplete(assetTypes, assets, orgId, {
+  mixedMode: true,
+  updateExisting: true,
+});
+```
+
+## Data Format
+
+### Asset Type JSON Structure
+
+```json
+[
+  {
+    "name": "Building",
+    "allowedParents": [],
+    "readPermissions": [],
+    "readWritePermissions": ["some-role"],
+    "typeSchema": {
+      "type": "object",
+      "properties": {
+        "example": {
+          "type": "string",
+          "title": "example"
+        }
+      }
+    }
+  }
+]
+```
+
+### Asset JSON Structure (Name-based)
+
+```json
+[
+  {
+    "name": "Main Building",
+    "type": "Building",
+    "readPermissions": [],
+    "readWritePermissions": ["some_role"],
+    "data": {
+      "example": "foo"
+    }
+  }
+]
+```
+
+### Asset JSON Structure (External Key-based)
+
+```json
+[
+  {
+    "name": "Main Building",
+    "externalKey": "EXT-BUILDING-001",
+    "type": "Building",
+    "parent": "EXT-SITE-001",
+    "readPermissions": [],
+    "readWritePermissions": ["some_role"],
+    "data": {
+      "example": "foo"
+    }
+  }
+]
+```
+
+## Important Notes
+
+- **Update Behavior**: When `updateExisting` is true, the entire asset object is replaced with the new data
+- **External Key Updates**: External key synchronization always attempts to update existing assets first
+- **Dependency Resolution**: Parent references can be either names or external keys, depending on the synchronization method
+- **Error Handling**: The system handles both creation and update scenarios gracefully
+- **Performance**: External key synchronization may be slower due to individual lookups for each asset
+- **Mixed Mode**: Allows combination of name-based and external key-based assets in the same synchronization run
+
+## API Endpoints Used
+
+- **Standard Asset Operations**:
+  - - Get all assets `GET /api/assets`
+  - - Create new asset `POST /api/assets`
+  - - Update existing asset by ID `PUT /api/assets/{id}`
+
+- **External Key Operations**:
+  - - Get asset by external key `GET /api/assets/external/{key}`
+  - - Update asset by external key `PUT /api/assets/external/{key}`
+
+## Limitations
+
+The example Code above is not an all-encompassing solution for synchronization. It has some limitations:
+
+### Partial state if errors occur
+
+If some error where to occur while synchronizing, a partiality-synced state will be left behind.
+
+### Only Assettypes and Assets
+
+Only these two Datatypes are synchronized. A Synchronization of other data can be done with a similar approach like shown here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2025.2.15",
+  "version": "2025.3.2",
   "description": "Module for easy access to the HahnPRO Cloud API",
   "license": "MIT",
   "author": {
@@ -8,9 +8,9 @@
     "url": "https://hahnpro.com"
   },
   "dependencies": {
-    "axios": "1.10.0",
+    "axios": "1.11.0",
     "eventsource": "4.0.0",
-    "form-data": "4.0.3",
+    "form-data": "4.0.4",
     "jose": "5.10.0",
     "jwt-decode": "4.0.0",
     "p-queue": "6.6.2",

package/src/lib/interfaces/ai.interface.d.ts

@@ -65,6 +65,7 @@ export interface UserMessage extends BaseMessage {
     role: 'user';
     content?: string;
     hidden?: boolean;
+    useWebSearch?: boolean;
 }
 export type Message = AssistantMessage | SystemMessage | ToolMessage | UserMessage;
 export interface SpeechToken {

package/src/lib/interfaces/asset.interface.d.ts

@@ -27,6 +27,7 @@ export type AssetTypeRevision = AssetType & {
 };
 export interface Asset {
     id?: string;
+    externalKey?: string;
     name: string;
     type: string | AssetType;
     type$name?: string;

package/src/lib/mock/api.mock.d.ts

@@ -15,6 +15,7 @@ import { Label } from '../label.interface';
 import { NotificationRuleService } from '../notification-rule.service';
 import { Notification } from '../notification.interface';
 import { Organization } from '../organization.interface';
+import { ProxyService } from '../proxy.service';
 import { Secret } from '../secret.interface';
 import { AiService } from '../services';
 import { Artifact } from '../storage.interface';
@@ -71,7 +72,7 @@ export declare class MockAPI implements API {
     flowModules: FlowModuleService;
     labels: LabelMockService;
     notificationRules: NotificationRuleService;
-    proxy: any;
+    proxy: ProxyService;
     secrets: SecretMockService;
     tasks: TaskMockService;
     timeSeries: TimeseriesMockService;
@@ -80,6 +81,7 @@ export declare class MockAPI implements API {
     notifications: NotificationMockService;
     organizations: OrganizationMockService;
     constructor(initData: MockAPIInitData);
+    getEverything(): Promise<{}>;
 }
 export type Identity<T> = {
     [P in keyof T]: T[P];

package/src/lib/mock/api.mock.js

@@ -206,5 +206,31 @@ class MockAPI {
         this.organizations = new organization_mock_service_1.OrganizationMockService(organizations1);
         this.httpClient = new http_mock_service_1.HttpMockService();
     }
+    async getEverything() {
+        const results = {
+            assets: await this.assets.getMany(),
+            assetTypes: await this.assetTypes.getMany(),
+            contents: await this.contents.getMany(),
+            endpoints: await this.endpoints.getMany(),
+            secrets: await this.secrets.getMany(),
+            timeSeries: await this.timeSeries.getMany(),
+            tasks: await this.tasks.getMany(),
+            events: await this.events.getMany(),
+            flows: await this.flows.getMany(),
+            flowDeployments: await this.flowDeployments.getMany(),
+            flowFunctions: await this.flowFunctions.getMany(),
+            flowModules: await this.flowModules.getMany(),
+            labels: await this.labels.getMany(),
+            vault: await this.vault.getMany(),
+            notifications: await this.notifications.getMany(),
+            organizations: await this.organizations.getMany(),
+        };
+        return Object.keys(results).reduce((previousValue, currentValue) => {
+            if (results[currentValue].total > 0) {
+                previousValue[currentValue] = results[currentValue];
+            }
+            return previousValue;
+        }, {});
+    }
 }
 exports.MockAPI = MockAPI;

package/src/lib/mock/asset.mock.service.d.ts

@@ -1,5 +1,6 @@
 import FormData from 'form-data';
 import { Paginated, RequestParameter } from '../data.interface';
+import { TokenOption } from '../http.service';
 import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from '../interfaces';
 import { AssetService } from '../services';
 import { APIBaseMock } from './api-base.mock';
@@ -27,5 +28,7 @@ export declare class AssetMockService extends BaseService implements AssetServic
     getRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
     rollback(assetId: string, revisionId: string): Promise<Asset>;
     deleteRevision(assetId: string, revisionId: string): Promise<any>;
+    findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
+    updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
 }
 export {};

package/src/lib/mock/asset.mock.service.js

@@ -111,5 +111,14 @@ class AssetMockService extends BaseService {
         this.revisions.splice(index, 1);
         return Promise.resolve(revisionId);
     }
+    findOneExternal(key, options) {
+        return Promise.resolve(this.data.find((asset) => asset.externalKey === key));
+    }
+    async updateOneExternal(key, dto, options) {
+        const asset = await this.findOneExternal(key, options);
+        const index = this.data.findIndex((asset) => asset.externalKey === key);
+        this.data[index] = { ...asset, ...dto };
+        return Promise.resolve(this.data[index]);
+    }
 }
 exports.AssetMockService = AssetMockService;

package/src/lib/mock/content.mock.service.js

@@ -78,8 +78,9 @@ class ContentMockService extends BaseService {
         const page = this.getItems(params, false);
         return Promise.resolve(page);
     }
-    upload(form) {
-        return Promise.resolve(undefined);
+    async upload(form) {
+        const content = await this.addOne({});
+        return Promise.resolve(content);
     }
 }
 exports.ContentMockService = ContentMockService;

package/src/lib/mock/data.mock.service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataMockService = void 0;
+const crypto_1 = require("crypto");
 const data_interface_1 = require("../data.interface");
 const data_service_1 = require("../data.service");
 class DataMockService extends data_service_1.DataService {
@@ -13,8 +14,9 @@ class DataMockService extends data_service_1.DataService {
         return Promise.all(map);
     }
     addOne(dto) {
-        this.data.push(dto);
-        return Promise.resolve(dto);
+        const dtoWithId = { id: (0, crypto_1.randomUUID)(), ...dto };
+        this.data.push(dtoWithId);
+        return Promise.resolve(dtoWithId);
     }
     deleteOne(id) {
         const index = this.data.findIndex((v) => v.id === id);

package/src/lib/mock/http.mock.service.d.ts

@@ -1,9 +1,9 @@
-import { Method } from 'axios';
+import { AxiosInstance, Method } from 'axios';
 import { Config, HttpClient, Issuer, TokenOption } from '../http.service';
 import { TokenSet } from '../token-set';
 export declare class HttpMockService extends HttpClient {
-    protected readonly authAxiosInstance: any;
-    protected readonly axiosInstance: any;
+    protected readonly authAxiosInstance: AxiosInstance;
+    protected readonly axiosInstance: AxiosInstance;
     constructor();
     delete: <T>(_url: string, _config: Config | undefined) => Promise<T>;
     get: <T>(_url: string, _config: Config | undefined) => Promise<T>;

package/src/lib/services/asset.service.d.ts

@@ -20,5 +20,7 @@ export declare class AssetService extends BaseService {
     getRevisions(assetId: string, options?: TokenOption): Promise<Paginated<AssetRevision[]>>;
     rollback(assetId: string, revisionId: string, options?: TokenOption): Promise<Asset>;
     deleteRevision(assetId: string, revisionId: string, options?: TokenOption): Promise<any>;
+    findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
+    updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
 }
 export {};

package/src/lib/services/asset.service.js

@@ -34,13 +34,10 @@ class AssetService extends BaseService {
         return this.httpClient.get(`${this.basePath}/${assetId}/attachments`, options);
     }
     getEventLevelOverride(ids, causes, options = {}) {
-        return this.httpClient.get(`${this.basePath}/eventcauses`, {
-            params: { ids: ids.join(','), causes: causes.join(',') },
-            ...options,
-        });
+        return this.httpClient.post(`${this.basePath}/event-causes`, { ids, causes }, options);
     }
     updateEventCausesAsset(id, dto, options = {}) {
-        return this.httpClient.put(`${this.basePath}/${id}/eventcauses`, dto, options);
+        return this.httpClient.put(`${this.basePath}/${id}/event-causes`, dto, options);
     }
     getRevisions(assetId, options = {}) {
         return this.httpClient.get(`${this.basePath}/${assetId}/revisions`, options);
@@ -51,5 +48,11 @@ class AssetService extends BaseService {
     deleteRevision(assetId, revisionId, options = {}) {
         return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`, options);
     }
+    findOneExternal(key, options = {}) {
+        return this.httpClient.get(`${this.basePath}/external/${key}`, options);
+    }
+    updateOneExternal(key, dto, options = {}) {
+        return this.httpClient.put(`${this.basePath}/external/${key}`, dto, options);
+    }
 }
 exports.AssetService = AssetService;