Add EUDIPLO tests (#831)

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
Co-authored-by: mkuhn <magnus.kuhn@js-soft.com>
Co-authored-by: Julian König <33655937+jkoenig134@users.noreply.github.com>
Co-authored-by: Magnus Kuhn <127854942+Magnus-Kuhn@users.noreply.github.com>

Author: 4 people

.dev/eudiplo-assets/service.db

@@ -30,6 +30,8 @@
         "test:teardown": "docker compose -f .dev/compose.yml down -fsv"
     },
     "devDependencies": {
+        "@babel/preset-env": "^7.28.5",
+        "@babel/preset-typescript": "^7.28.5",
         "@js-soft/eslint-config-ts": "^2.0.4",
         "@js-soft/license-check": "^1.0.10",
         "@types/jest": "^30.0.0",

.dev/eudiplo-assets/uploads/6749e992-9ee7-4794-b79d-bd895d115b4b

@@ -43,13 +43,16 @@
         "testEnvironment": "node",
         "testTimeout": 60000,
         "transform": {
-            "^.+\\.ts$": [
+            "^.+\\.(t|j)s$": [
                 "ts-jest",
                 {
                     "tsconfig": "test/tsconfig.json"
                 }
             ]
-        }
+        },
+        "transformIgnorePatterns": [
+            "<rootDir>/node_modules/(?!(@noble|@stablelib|@credo\\-ts/core/node_modules/uuid)/)"
+        ]
     },
     "dependencies": {
         "@js-soft/docdb-access-loki": "^1.3.1",

package-lock.json

@@ -3,7 +3,8 @@
     "compilerOptions": {
         "baseUrl": "../",
         "noEmit": true,
-        "composite": false
+        "composite": false,
+        "allowJs": true // we want to use the ts compiler to compile ESM node modules into CJS which is understood by jest. This is required since those node modules are javascript.
     },
     "files": ["../../../node_modules/jest-expect-message/types/index.d.ts"],
     "include": ["**/*.ts", "../src/**/*.ts"],

package.json

@@ -50,17 +50,20 @@
         "testEnvironment": "node",
         "testTimeout": 60000,
         "transform": {
-            "^.+\\.ts$": [
+            "^.+\\.(t|j)s$": [
                 "ts-jest",
                 {
                     "tsconfig": "test/tsconfig.json"
                 }
             ]
-        }
+        },
+        "transformIgnorePatterns": [
+            "<rootDir>/node_modules/(?!(@noble|@stablelib|@credo\\-ts/core/node_modules/uuid)/)"
+        ]
     },
     "dependencies": {
-        "@credo-ts/core": "v0.6.0-alpha-20250919145226",
-        "@credo-ts/openid4vc": "v0.6.0-alpha-20250919145226",
+        "@credo-ts/core": "v0.6.0-alpha-20251110135447",
+        "@credo-ts/openid4vc": "v0.6.0-alpha-20251110135447",
         "@js-soft/docdb-querytranslator": "^1.1.6",
         "@js-soft/ts-serval": "2.0.14",
         "@js-soft/ts-utils": "2.3.5",

packages/app-runtime/package.json

@@ -4,13 +4,14 @@ import {
     DependencyManager,
     DidKey,
     InjectionSymbols,
+    Kms,
     LogLevel,
+    StorageVersionRecord,
     type InitConfig,
     type KeyDidCreateOptions,
     type ModulesMap,
     type VerificationMethod
 } from "@credo-ts/core";
-import { KeyManagementModuleConfig } from "@credo-ts/core/build/modules/kms";
 import { AccountController } from "@nmshd/transport";
 import { EventEmitter } from "events";
 import webSocket from "ws";
@@ -70,10 +71,9 @@ export class BaseAgent<AgentModules extends ModulesMap> {
     public async initializeAgent(privateKey: string): Promise<void> {
         // as we are not using askar we need to set the storage version
         const storage = this.agent.dependencyManager.resolve<EnmeshedStorageService<any>>(InjectionSymbols.StorageService);
-        const versionRecord = { id: "STORAGE_VERSION_RECORD_ID", storageVersion: "0.5.0", value: "0.5.0" };
-        await storage.save(this.agent.context, versionRecord);
+        await storage.save(this.agent.context, new StorageVersionRecord({ storageVersion: "0.5.0" }));
 
-        const kmsConfig = this.agent.dependencyManager.resolve(KeyManagementModuleConfig);
+        const kmsConfig = this.agent.dependencyManager.resolve(Kms.KeyManagementModuleConfig);
         kmsConfig.registerBackend(new EnmshedHolderKeyManagmentService());
 
         if (kmsConfig.backends.length === 0) throw new Error("No KMS backend registered");

packages/app-runtime/test/tsconfig.json

@@ -1,26 +1,4 @@
-import { AgentContext } from "@credo-ts/core";
-import {
-    KeyManagementService,
-    KmsCreateKeyOptions,
-    KmsCreateKeyReturn,
-    KmsCreateKeyType,
-    KmsDecryptOptions,
-    KmsDecryptReturn,
-    KmsDeleteKeyOptions,
-    KmsEncryptOptions,
-    KmsEncryptReturn,
-    KmsImportKeyOptions,
-    KmsImportKeyReturn,
-    KmsJwkPrivate,
-    KmsJwkPublic,
-    KmsOperation,
-    KmsRandomBytesOptions,
-    KmsRandomBytesReturn,
-    KmsSignOptions,
-    KmsSignReturn,
-    KmsVerifyOptions,
-    KmsVerifyReturn
-} from "@credo-ts/core/build/modules/kms";
+import { AgentContext, Kms } from "@credo-ts/core";
 import { ec as EC } from "elliptic";
 import _sodium from "libsodium-wrappers";
 import sjcl from "sjcl";
@@ -31,7 +9,7 @@ export interface JwkKeyPair {
     keyType?: string;
 }
 
-export class EnmshedHolderKeyManagmentService implements KeyManagementService {
+export class EnmshedHolderKeyManagmentService implements Kms.KeyManagementService {
     public static readonly backend = "fakeKeyManagementService";
 
     public readonly backend = EnmshedHolderKeyManagmentService.backend;
@@ -70,7 +48,7 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         // console.log(`FKM: global instance state ${JSON.stringify(Array.from((globalThis as any).fakeKeyStorage.entries()))}`);
     }
 
-    public isOperationSupported(agentContext: AgentContext, operation: KmsOperation): boolean {
+    public isOperationSupported(agentContext: AgentContext, operation: Kms.KmsOperation): boolean {
         agentContext.config.logger.debug(`EKM: Checking if operation is supported: ${JSON.stringify(operation)}`);
         if (operation.operation === "createKey") {
             if (operation.type.kty === "OKP") {
@@ -98,18 +76,16 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         }
         return false;
     }
-
-    public getPublicKey(agentContext: AgentContext, keyId: string): Promise<KmsJwkPublic> {
+    public getPublicKey(agentContext: AgentContext, keyId: string): Promise<Kms.KmsJwkPublic> {
         const keyPair = this.keystore.get(keyId);
         if (!keyPair) {
             agentContext.config.logger.error(`EKM: Key with id ${keyId} not found`);
             throw new Error(`Key with id ${keyId} not found`);
         }
 
-        return Promise.resolve((JSON.parse(keyPair) as JwkKeyPair).publicKey as KmsJwkPublic);
+        return Promise.resolve((JSON.parse(keyPair) as JwkKeyPair).publicKey as Kms.KmsJwkPublic);
     }
-
-    public async createKey<Type extends KmsCreateKeyType>(agentContext: AgentContext, options: KmsCreateKeyOptions<Type>): Promise<KmsCreateKeyReturn<Type>> {
+    public async createKey<Type extends Kms.KmsCreateKeyType>(agentContext: AgentContext, options: Kms.KmsCreateKeyOptions<Type>): Promise<Kms.KmsCreateKeyReturn<Type>> {
         options.keyId ??= "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
             // Use libsodium's randombytes_uniform for secure random number generation
             const r = _sodium.randombytes_uniform(16);
@@ -151,8 +127,8 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
             this.updateGlobalInstance(this.keystore);
             return await Promise.resolve({
                 keyId: options.keyId,
-                publicJwk: publicJwk as KmsJwkPublic
-            } as KmsCreateKeyReturn<Type>);
+                publicJwk: publicJwk as Kms.KmsJwkPublic
+            } as Kms.KmsCreateKeyReturn<Type>);
         }
 
         await _sodium.ready;
@@ -186,16 +162,14 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         this.updateGlobalInstance(this.keystore);
         return await Promise.resolve({
             keyId: options.keyId,
-            publicJwk: publicJwk as KmsJwkPublic
-        } as KmsCreateKeyReturn<Type>);
+            publicJwk: publicJwk as Kms.KmsJwkPublic
+        } as Kms.KmsCreateKeyReturn<Type>);
     }
-
-    public importKey<Jwk extends KmsJwkPrivate>(agentContext: AgentContext, options: KmsImportKeyOptions<Jwk>): Promise<KmsImportKeyReturn<Jwk>> {
+    public importKey<Jwk extends Kms.KmsJwkPrivate>(agentContext: AgentContext, options: Kms.KmsImportKeyOptions<Jwk>): Promise<Kms.KmsImportKeyReturn<Jwk>> {
         agentContext.config.logger.debug(`EKM: Importing key with  ${JSON.stringify(options)}`);
         throw new Error("Method not implemented.");
     }
-
-    public deleteKey(agentContext: AgentContext, options: KmsDeleteKeyOptions): Promise<boolean> {
+    public deleteKey(agentContext: AgentContext, options: Kms.KmsDeleteKeyOptions): Promise<boolean> {
         if (this.keystore.has(options.keyId)) {
             agentContext.config.logger.debug(`EKM: Deleting key with id ${options.keyId}`);
             this.keystore.delete(options.keyId);
@@ -204,8 +178,7 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         }
         throw new Error(`key with id ${options.keyId} not found. and cannot be deleted`);
     }
-
-    public async sign(agentContext: AgentContext, options: KmsSignOptions): Promise<KmsSignReturn> {
+    public async sign(agentContext: AgentContext, options: Kms.KmsSignOptions): Promise<Kms.KmsSignReturn> {
         agentContext.config.logger.debug(`EKM: Signing data with key id ${options.keyId} using algorithm ${options.algorithm}`);
 
         const stringifiedKeyPair = this.keystore.get(options.keyId);
@@ -236,7 +209,7 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
 
             return await Promise.resolve({
                 signature: signatureBytes
-            } as KmsSignReturn);
+            } as Kms.KmsSignReturn);
         }
 
         await _sodium.ready;
@@ -263,11 +236,11 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         const signature = sodium.crypto_sign_detached(options.data, fullPrivateKeyBytes);
 
         return {
-            signature: signature
+            signature: signature as Uint8Array<ArrayBuffer> // I hope this cast doesn't paper over something
         };
     }
 
-    public verify(agentContext: AgentContext, options: KmsVerifyOptions): Promise<KmsVerifyReturn> {
+    public verify(agentContext: AgentContext, options: Kms.KmsVerifyOptions): Promise<Kms.KmsVerifyReturn> {
         agentContext.config.logger.debug(`EKM: Verifying signature with key id ${options.key.keyId} using algorithm ${options.algorithm}`);
         // Use P-256 (aka secp256r1)
         const ec = new EC("p256");
@@ -293,7 +266,7 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         const dataHash = ec.hash().update(options.data).digest();
         try {
             const verified = key.verify(dataHash, signature);
-            return Promise.resolve({ verified: verified } as KmsVerifyReturn);
+            return Promise.resolve({ verified: verified } as Kms.KmsVerifyReturn);
         } catch (e) {
             agentContext.config.logger.error(`EKM: Error during signature verification: ${e}`);
             throw e;
@@ -387,7 +360,7 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         return hashBuf.subarray(0, keyLength / 8);
     }
 
-    public encrypt(agentContext: AgentContext, options: KmsEncryptOptions): Promise<KmsEncryptReturn> {
+    public encrypt(agentContext: AgentContext, options: Kms.KmsEncryptOptions): Promise<Kms.KmsEncryptReturn> {
         try {
             // encryption via A-256-GCM
             // we will call the services side bob and the incoming side alice
@@ -437,12 +410,11 @@ export class EnmshedHolderKeyManagmentService implements KeyManagementService {
         }
     }
 
-    public decrypt(agentContext: AgentContext, options: KmsDecryptOptions): Promise<KmsDecryptReturn> {
+    public decrypt(agentContext: AgentContext, options: Kms.KmsDecryptOptions): Promise<Kms.KmsDecryptReturn> {
         agentContext.config.logger.debug(`EKM: Decrypting data with key id ${options.key.keyId} using options ${options}`);
         throw new Error("Method not implemented.");
     }
-
-    public randomBytes(agentContext: AgentContext, options: KmsRandomBytesOptions): KmsRandomBytesReturn {
+    public randomBytes(agentContext: AgentContext, options: Kms.KmsRandomBytesOptions): Kms.KmsRandomBytesReturn {
         agentContext.config.logger.debug(`EKM: Generating ${options.length} random bytes`);
         return _sodium.randombytes_buf(options.length); // Uint8Array
     }

packages/consumption/package.json

@@ -194,34 +194,27 @@ export class EnmeshedStorageService<T extends BaseRecord> implements StorageServ
         agentContext.config.logger.debug(`Finding records by query ${JSON.stringify(query)} and options ${JSON.stringify(queryOptions)}`);
         const records: T[] = [];
         for (const record of await this.getAll(agentContext, recordClass)) {
-            let match = true;
-            for (const [key, value] of Object.entries(query)) {
-                if ((record as any)[key] !== value) {
-                    match = false;
-                    break;
-                }
-            }
-            if (match) {
+            if (this.matchesQuery(record, query)) {
                 records.push(record);
             }
         }
         if (records.length === 0) {
             // try to recover over local storage - temporary fix
             for (const record of this.storage.values()) {
-                let match = true;
-                // there may be keys labeled with an $or - solve them accordingly
-                // TODO: $or and other operators not yet supported
-                for (const [key, value] of Object.entries(query)) {
-                    if ((record as any)[key] !== value) {
-                        match = false;
-                        break;
-                    }
-                }
-                if (match) {
+                if (this.matchesQuery(record, query)) {
                     records.push(record);
                 }
             }
         }
         return records;
     }
+
+    private matchesQuery(record: BaseRecord, query: Query<T>): boolean {
+        return Object.entries(query).every(([key, value]) => {
+            if (key === "$or") {
+                return (value as any[]).some((subquery) => this.matchesQuery(record, subquery));
+            }
+            return record.getTags()[key] === value;
+        });
+    }
 }