dvlprsh-dcql-test 0.1.8

package/src/test/pathMatch.spec.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { SdJwtVcCredential } from '../credentials/sdjwtvc.credential';
+import { pathMatch } from '../match';
+
+describe('pathMatch', () => {
+  let credential: SdJwtVcCredential;
+
+  beforeEach(() => {
+    credential = new SdJwtVcCredential('test-id', 'test-vct-value');
+  });
+
+  describe('processPathPointer', () => {
+    describe('String components - object key selection', () => {
+      it('should select a property by name', () => {
+        const data = { name: 'John', age: 30 };
+        const result = pathMatch(['name'], data);
+        expect(result).toEqual(['John']);
+      });
+
+      it('should navigate nested objects', () => {
+        const data = { person: { name: 'John', age: 30 } };
+        const result = pathMatch(['person', 'name'], data);
+        expect(result).toEqual(['John']);
+      });
+
+      it('should throw error when accessing string key on non-object', () => {
+        const data = ['name', 'age'];
+        expect(() => pathMatch(['0'], data)).toThrow(
+          'Path component requires object but found non-object element',
+        );
+      });
+
+      it('should throw error when accessing string key on null', () => {
+        const data = { name: null };
+        expect(() => pathMatch(['name', 'prop'], data)).toThrow(
+          'Path component requires object but found non-object element',
+        );
+      });
+
+      it('should throw error when property does not exist and results in empty selection', () => {
+        const data = { name: 'John' };
+        expect(() => pathMatch(['age'], data)).toThrow(
+          'No elements selected after processing path component',
+        );
+      });
+    });
+
+    describe('Null components - all array elements selection', () => {
+      it('should select all elements from an array', () => {
+        const data = { items: [1, 2, 3] };
+        const result = pathMatch(['items', null], data);
+        expect(result).toEqual([1, 2, 3]);
+      });
+
+      it('should throw error when using null on non-array', () => {
+        const data = { items: 'not-an-array' };
+        expect(() => pathMatch(['items', null], data)).toThrow(
+          'Null path component requires array but found non-array element',
+        );
+      });
+
+      it('should process all array elements for the next segment', () => {
+        const data = {
+          people: [
+            { name: 'John', roles: ['admin', 'user'] },
+            { name: 'Jane', roles: ['editor'] },
+          ],
+        };
+        // Select all people, then all roles for each person
+        const result = pathMatch(['people', null, 'roles', null], data);
+        expect(result).toEqual(['admin', 'user', 'editor']);
+      });
+
+      it('should throw error on empty array', () => {
+        const data = { items: [] };
+        expect(() => pathMatch(['items', null], data)).toThrow(
+          'No elements selected after processing path component',
+        );
+      });
+    });
+
+    describe('Number components - array index selection', () => {
+      // Note: This isn't in the type definition but the implementation handles it
+      it('should select element by index from an array', () => {
+        const data = { items: [1, 2, 3] };
+        // Using any to bypass TypeScript's type checking
+        const path: any = ['items', 1];
+        const result = pathMatch(path, data);
+        expect(result).toEqual([2]); // 0-based index, so index 1 is the second element (2)
+      });
+
+      it('should throw error when using number on non-array', () => {
+        const data = { items: 'not-an-array' };
+        // Using any to bypass TypeScript's type checking
+        const path: any = ['items', 1];
+        expect(() => pathMatch(path, data)).toThrow(
+          'Numeric path component requires array but found non-array element',
+        );
+      });
+
+      it('should throw error when index is out of bounds', () => {
+        const data = { items: [1, 2, 3] };
+        // Using any to bypass TypeScript's type checking
+        const path: any = ['items', 10]; // Index out of bounds
+        expect(() => pathMatch(path, data)).toThrow(
+          'No elements selected after processing path component',
+        );
+      });
+    });
+
+    describe('Complex paths and combinations', () => {
+      it('should handle complex nested structures', () => {
+        const data = {
+          organization: {
+            departments: [
+              {
+                name: 'Engineering',
+                teams: [
+                  { name: 'Frontend', members: ['Alice', 'Bob'] },
+                  { name: 'Backend', members: ['Charlie', 'Dave'] },
+                ],
+              },
+              {
+                name: 'Marketing',
+                teams: [{ name: 'Growth', members: ['Eve', 'Frank'] }],
+              },
+            ],
+          },
+        };
+
+        // Get all team names
+        const teamNames = pathMatch(
+          ['organization', 'departments', null, 'teams', null, 'name'],
+          data,
+        );
+        expect(teamNames).toEqual(['Frontend', 'Backend', 'Growth']);
+
+        // Get all members from all teams
+        const allMembers = pathMatch(
+          ['organization', 'departments', null, 'teams', null, 'members', null],
+          data,
+        );
+        expect(allMembers).toEqual([
+          'Alice',
+          'Bob',
+          'Charlie',
+          'Dave',
+          'Eve',
+          'Frank',
+        ]);
+      });
+
+      it('should throw error for invalid path component', () => {
+        const data = { name: 'John' };
+        // Using any to bypass TypeScript's type checking
+        const path: any = ['name', true];
+        expect(() => pathMatch(path, data)).toThrow(
+          'Invalid path component: true',
+        );
+      });
+    });
+  });
+});

package/src/test/sdjwtvc-credentials.spec.ts

@@ -0,0 +1,259 @@
+import { describe, expect, it } from 'vitest';
+import { SdJwtVcCredential } from '../credentials/sdjwtvc.credential';
+import { Claims, ClaimSet, TrustedAuthority } from '../type';
+
+describe('Credentials', () => {
+  describe('SdJwtVcCredential', () => {
+    it('should create an instance with required properties', () => {
+      const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+
+      expect(credential).toBeDefined();
+      expect(credential.id).toBe('test-id');
+      expect(credential.vct_values).toEqual(['test-vct-value']);
+    });
+
+    describe('setMultiple', () => {
+      it('should set multiple flag', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+
+        const result = credential.setMultiple(true);
+
+        // Should return this for chaining
+        expect(result).toBe(credential);
+
+        // Verify it was set by checking serialized output
+        const serialized = credential.serialize();
+        expect(serialized.multiple).toBe(true);
+      });
+    });
+
+    describe('setTrustedAuthorities', () => {
+      it('should set trusted authorities', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        const authorities: TrustedAuthority[] = [
+          { type: 'aki', value: ['test-value'] },
+        ];
+
+        const result = credential.setTrustedAuthorities(authorities);
+
+        // Should return this for chaining
+        expect(result).toBe(credential);
+
+        // Verify it was set by checking serialized output
+        const serialized = credential.serialize();
+        expect(serialized.trusted_authorities).toEqual(authorities);
+      });
+    });
+
+    describe('setRequireCryptographicHolderBinding', () => {
+      it('should set cryptographic holder binding requirement', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+
+        const result = credential.setRequireCryptographicHolderBinding(false);
+
+        // Should return this for chaining
+        expect(result).toBe(credential);
+
+        // Verify it was set by checking serialized output
+        const serialized = credential.serialize();
+        expect(serialized.require_cryptographic_holder_binding).toBe(false);
+      });
+    });
+
+    describe('setClaims', () => {
+      it('should set claims', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        const claims: Claims[] = [
+          { path: ['$.vc.credentialSubject.firstName'], value: ['John'] },
+          { path: ['$.vc.credentialSubject.lastName'], value: ['Doe'] },
+        ];
+
+        const result = credential.setClaims(claims);
+
+        // Should return this for chaining
+        expect(result).toBe(credential);
+
+        // Verify it was set by checking serialized output
+        const serialized = credential.serialize();
+        expect(serialized.claims).toEqual(claims);
+      });
+    });
+
+    describe('setClaimSets', () => {
+      it('should set claim sets when claims are properly set', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        const claims: Claims[] = [
+          {
+            id: 'claim1',
+            path: ['$.vc.credentialSubject.firstName'],
+            value: ['John'],
+          },
+          {
+            id: 'claim2',
+            path: ['$.vc.credentialSubject.lastName'],
+            value: ['Doe'],
+          },
+        ];
+
+        credential.setClaims(claims);
+
+        const claimSets: ClaimSet[] = [['claim1', 'claim2']];
+
+        const result = credential.setClaimSets(claimSets);
+
+        // Should return this for chaining
+        expect(result).toBe(credential);
+
+        // Verify it was set by checking serialized output
+        const serialized = credential.serialize();
+        expect(serialized.claim_sets).toEqual(claimSets);
+      });
+
+      it('should throw error if claims are not set', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        const claimSets: ClaimSet[] = [['claim1']];
+
+        expect(() => credential.setClaimSets(claimSets)).toThrow(
+          'Claims must be set before claim sets',
+        );
+      });
+
+      it('should throw error if claims do not have IDs', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        // Claims without IDs
+        const claims: Claims[] = [
+          { path: ['$.vc.credentialSubject.firstName'], value: ['John'] },
+        ];
+
+        credential.setClaims(claims);
+
+        const claimSets: ClaimSet[] = [['claim1']];
+
+        expect(() => credential.setClaimSets(claimSets)).toThrow(
+          'Claims must not have an id before claim sets',
+        );
+      });
+    });
+
+    describe('serialize', () => {
+      it('should serialize credential with all properties', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+        const authorities: TrustedAuthority[] = [
+          { type: 'aki', value: ['test-value'] },
+        ];
+        const claims: Claims[] = [
+          {
+            id: 'claim1',
+            path: ['$.vc.credentialSubject.firstName'],
+            value: ['John'],
+          },
+        ];
+        const claimSets: ClaimSet[] = [['claim1']];
+
+        credential
+          .setMultiple(true)
+          .setTrustedAuthorities(authorities)
+          .setRequireCryptographicHolderBinding(false)
+          .setClaims(claims)
+          .setClaimSets(claimSets);
+
+        const serialized = credential.serialize();
+
+        expect(serialized).toEqual({
+          id: 'test-id',
+          format: 'dc+sd-jwt',
+          meta: { vct_values: ['test-vct-value'] },
+          multiple: true,
+          trusted_authorities: authorities,
+          require_cryptographic_holder_binding: false,
+          claims: claims,
+          claim_sets: claimSets,
+        });
+      });
+
+      it('should serialize credential with minimal properties', () => {
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value']);
+
+        const serialized = credential.serialize();
+
+        expect(serialized).toEqual({
+          id: 'test-id',
+          format: 'dc+sd-jwt',
+          meta: { vct_values: ['test-vct-value'] },
+          multiple: undefined,
+          trusted_authorities: undefined,
+          require_cryptographic_holder_binding: undefined,
+          claims: undefined,
+          claim_sets: undefined,
+        });
+      });
+    });
+
+    describe('Match claim functionality', () => {
+      // Access the private matchClaim method for testing
+
+      it('should match a simple claim', () => {
+        const claim = { path: ['name'] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct_values: ['test-vct-value'], name: 'John' };
+        expect(credential.match(data)).toStrictEqual({
+          match: true,
+          matchedClaims: [{ path: ['name'] }],
+        });
+      });
+
+      it('should match a claim with value restriction', () => {
+        const claim = { path: ['age'], value: [30, 40] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct: 'test-vct-value', age: 30 };
+        expect(credential.match(data)).toStrictEqual({
+          match: true,
+          matchedClaims: [{ path: ['age'], value: [30, 40] }],
+        });
+      });
+
+      it("should not match when value doesn't match restriction", () => {
+        const claim = { path: ['age'], value: [40, 50] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct: 'test-vct-value', age: 30 };
+        expect(credential.match(data)).toStrictEqual({ match: false });
+      });
+
+      it('should handle errors in path processing gracefully', () => {
+        const claim = { path: ['items', null] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct: 'test-vct-value', items: 'not-an-array' };
+        expect(credential.match(data)).toStrictEqual({ match: false });
+      });
+
+      it('should match array elements with null in path', () => {
+        const claim = { path: ['items', null], value: [3] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct: 'test-vct-value', items: [1, 2, 3, 4] };
+        expect(credential.match(data)).toStrictEqual({
+          match: true,
+          matchedClaims: [{ path: ['items', null], value: [3] }],
+        });
+      });
+
+      it("should return false when claim path doesn't exist", () => {
+        const claim = { path: ['nonexistent'] };
+        const credential = new SdJwtVcCredential('test-id', ['test-vct-value'], {
+          claims: [claim],
+        });
+        const data = { vct: 'test-vct-value', name: 'John' };
+        expect(credential.match(data)).toStrictEqual({ match: false });
+      });
+    });
+  });
+});

package/src/type.ts

@@ -0,0 +1,65 @@
+export type Format = 'dc+sd-jwt' | 'ldp_vc' | 'jwt_vc_json';
+
+export type TrustedAuthority = {
+  type: 'aki' | 'etsi_tl' | 'openid_federation';
+  value: string[];
+};
+
+export type Credential = {
+  id: string;
+  format: Format;
+
+  /** optional, default is false */
+  multiple?: boolean;
+  meta?: { vct_values: string[] } | { doctype_value: string };
+  trusted_authorities?: TrustedAuthority[];
+
+  /** optional, default is true */
+  require_cryptographic_holder_binding?: boolean;
+
+  claims?: Claims[];
+  claim_sets?: ClaimSet[];
+};
+
+export type CredentialIds = Array<string>;
+
+export type CredentialSet = {
+  options: CredentialIds[];
+  purpose?: string;
+
+  /** optional, default is true */
+  required?: boolean;
+};
+
+export type rawDCQL = {
+  credentials: Credential[];
+  credential_sets?: CredentialSet[];
+};
+
+export type Claims = {
+  /** optional, but if claim_sets is present, it is required */
+  id?: string;
+
+  path: Array<string | number | null>;
+
+  value?: Array<number | string | boolean>;
+};
+
+export type ClaimSet = string[];
+
+export type SdJwtVcCredentialQuery = Credential & {
+  format: 'dc+sd-jwt';
+  meta: {
+    vct_values: string[];
+  };
+};
+
+export type MatchResult =
+  | {
+      match: false;
+      matchedClaims?: undefined;
+    }
+  | {
+      match: true;
+      matchedClaims: Claims[];
+    };

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/dist", "**/*.spec.ts"]
+}

package/vitest.config.mts

@@ -0,0 +1,4 @@
+// vite.config.ts
+import { allEnvs } from '../../vitest.shared';
+
+export default allEnvs;