@liquidmetal-ai/drizzle 0.4.1 → 0.4.2

package/src/mrn.test.ts

@@ -0,0 +1,769 @@
+import { describe, expect, it } from 'vitest';
+import { parseMRN, parsePartialMRN, serializeMRN, serializePartialMRN } from './mrn';
+import type { MRNObject } from '@liquidmetal-ai/raindrop-framework';
+
+describe('MRN (Metal Resource Name)', () => {
+  describe('parseMRN', () => {
+    describe('valid MRN examples', () => {
+      it('should parse annotation:my-app:versionId:::', () => {
+        const result = parseMRN('annotation:my-app:versionId:::');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+        });
+      });
+
+      it('should parse annotation:my-app:versionId:module::', () => {
+        const result = parseMRN('annotation:my-app:versionId:module::');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+          module: 'module',
+        });
+      });
+
+      it('should parse annotation:my-app:versionId:module:someKey', () => {
+        const result = parseMRN('annotation:my-app:versionId:module:someKey:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+          module: 'module',
+          key: 'someKey',
+        });
+      });
+
+      it('should parse annotation:my-app:versionId:module:someItem^someKey:', () => {
+        const result = parseMRN('annotation:my-app:versionId:module:someItem^someKey:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+          module: 'module',
+          item: 'someItem',
+          key: 'someKey',
+        });
+      });
+
+      it('should parse annotation:my-app:versionId:module:someItem^someKey:someRevision', () => {
+        const result = parseMRN('annotation:my-app:versionId:module:someItem^someKey:someRevision');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+          module: 'module',
+          item: 'someItem',
+          key: 'someKey',
+          revision: 'someRevision',
+        });
+      });
+
+      it('should parse annotation:my-app:versionId:module:aDifferentKey:someRevision', () => {
+        const result = parseMRN('annotation:my-app:versionId:module:aDifferentKey:someRevision');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'versionId',
+          module: 'module',
+          key: 'aDifferentKey',
+          revision: 'someRevision',
+        });
+      });
+    });
+
+    describe('basic valid cases', () => {
+      it('should parse minimal annotation MRN', () => {
+        const result = parseMRN('annotation:app:v1:::');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+        });
+      });
+
+      it('should parse minimal label MRN', () => {
+        const result = parseMRN('label:app:v1:::');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'app',
+          versionId: 'v1',
+        });
+      });
+
+      it('should parse MRN with module only', () => {
+        const result = parseMRN('annotation:app:v1:auth::');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+        });
+      });
+
+      it('should parse MRN with module and key', () => {
+        const result = parseMRN('annotation:app:v1:auth:secretKey:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          key: 'secretKey',
+        });
+      });
+
+      it('should parse MRN with module, key, and revision', () => {
+        const result = parseMRN('annotation:app:v1:auth:secretKey:rev123');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          key: 'secretKey',
+          revision: 'rev123',
+        });
+      });
+
+      it('should parse MRN with item and key using ^ separator', () => {
+        const result = parseMRN('annotation:app:v1:auth:user^email:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          item: 'user',
+          key: 'email',
+        });
+      });
+
+      it('should parse MRN with item, key, and revision', () => {
+        const result = parseMRN('annotation:app:v1:auth:user^email:rev456');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          item: 'user',
+          key: 'email',
+          revision: 'rev456',
+        });
+      });
+
+      it('should parse MRN with empty key after ^', () => {
+        const result = parseMRN('annotation:app:v1:auth:user^:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          item: 'user',
+          key: '',
+        });
+      });
+
+      it('should parse label MRN with module and key', () => {
+        const result = parseMRN('label:myapp:v2:config:dbUrl:');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'myapp',
+          versionId: 'v2',
+          module: 'config',
+          key: 'dbUrl',
+        });
+      });
+
+      it('should parse label MRN with item and key', () => {
+        const result = parseMRN('label:myapp:v2:config:database^url:');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'myapp',
+          versionId: 'v2',
+          module: 'config',
+          item: 'database',
+          key: 'url',
+        });
+      });
+
+      it('should parse MRN with revision but no module', () => {
+        const result = parseMRN('annotation:app:v1:::rev1');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          revision: 'rev1',
+        });
+      });
+
+      it('should parse MRN with special characters in names', () => {
+        const result = parseMRN('annotation:my-app_test:v1.2.3:auth-module:api_key:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app_test',
+          versionId: 'v1.2.3',
+          module: 'auth-module',
+          key: 'api_key',
+        });
+      });
+
+      it('should parse MRN with numbers in components', () => {
+        const result = parseMRN('label:app123:v2:module456:item789^key000:');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'app123',
+          versionId: 'v2',
+          module: 'module456',
+          item: 'item789',
+          key: 'key000',
+        });
+      });
+
+      it('should parse MRN with long revision identifier', () => {
+        const result = parseMRN('annotation:app:v1:auth:secretKey:abc123def456ghi789');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'app',
+          versionId: 'v1',
+          module: 'auth',
+          key: 'secretKey',
+          revision: 'abc123def456ghi789',
+        });
+      });
+    });
+
+    describe('error cases', () => {
+      it('should throw error for too few parts', () => {
+        expect(() => parseMRN('annotation:app')).toThrow('Invalid MRN format');
+        expect(() => parseMRN('annotation:app:v1')).toThrow('Invalid MRN format');
+      });
+
+      it('should throw error for too many parts', () => {
+        expect(() => parseMRN('annotation:app:v1:module:key:revision:extra')).toThrow('Invalid MRN format');
+      });
+
+      it('should throw error for invalid type', () => {
+        expect(() => parseMRN('invalid:app:v1:::')).toThrow('Invalid MRN type: invalid');
+      });
+
+      it('should throw error for missing type', () => {
+        expect(() => parseMRN(':app:v1:::')).toThrow('MRN must contain type, applicationName, and versionId');
+      });
+
+      it('should throw error for missing applicationName', () => {
+        expect(() => parseMRN('annotation::v1:::')).toThrow('MRN must contain type, applicationName, and versionId');
+      });
+
+      it('should throw error for missing versionId', () => {
+        expect(() => parseMRN('annotation:app::::')).toThrow('MRN must contain type, applicationName, and versionId');
+      });
+
+      it('should throw error for empty string', () => {
+        expect(() => parseMRN('')).toThrow('Invalid MRN format');
+      });
+      it('should throw error for MRN with only colons', () => {
+        expect(() => parseMRN(':::::')).toThrow('MRN must contain type, applicationName, and versionId');
+      });
+
+      it('should throw error for unsupported type', () => {
+        expect(() => parseMRN('config:app:v1:::')).toThrow('Invalid MRN type: config');
+      });
+    });
+  });
+
+  describe('serializeMRN', () => {
+    it('should serialize minimal MRN object', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:::');
+    });
+
+    it('should serialize MRN object with module', () => {
+      const mrnObject: MRNObject = {
+        type: 'label',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+      };
+      expect(serializeMRN(mrnObject)).toBe('label:app:v1:auth::');
+    });
+
+    it('should serialize MRN object with module and key', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        key: 'secretKey',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:secretKey:');
+    });
+
+    it('should serialize MRN object with module, key, and revision', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        key: 'secretKey',
+        revision: 'rev123',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:secretKey:rev123');
+    });
+
+    it('should serialize MRN object with item and key using ^ separator', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        item: 'user',
+        key: 'email',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:user^email:');
+    });
+
+    it('should serialize MRN object with item, key, and revision', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        item: 'user',
+        key: 'email',
+        revision: 'rev456',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:user^email:rev456');
+    });
+
+    it('should serialize MRN object with item but no key', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        item: 'user',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:user^:');
+    });
+
+    it('should serialize MRN object with empty key', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        module: 'auth',
+        item: 'user',
+        key: '',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:auth:user^:');
+    });
+
+    it('should serialize label MRN object', () => {
+      const mrnObject: MRNObject = {
+        type: 'label',
+        applicationName: 'myapp',
+        versionId: 'v2',
+        module: 'config',
+        key: 'dbUrl',
+      };
+      expect(serializeMRN(mrnObject)).toBe('label:myapp:v2:config:dbUrl:');
+    });
+
+    it('should serialize MRN object with revision but no module', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'app',
+        versionId: 'v1',
+        revision: 'rev1',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:app:v1:::rev1');
+    });
+
+    it('should serialize MRN object with special characters', () => {
+      const mrnObject: MRNObject = {
+        type: 'annotation',
+        applicationName: 'my-app_test',
+        versionId: 'v1.2.3',
+        module: 'auth-module',
+        key: 'api_key',
+      };
+      expect(serializeMRN(mrnObject)).toBe('annotation:my-app_test:v1.2.3:auth-module:api_key:');
+    });
+
+    it('should serialize MRN object with numbers', () => {
+      const mrnObject: MRNObject = {
+        type: 'label',
+        applicationName: 'app123',
+        versionId: 'v2',
+        module: 'module456',
+        item: 'item789',
+        key: 'key000',
+      };
+      expect(serializeMRN(mrnObject)).toBe('label:app123:v2:module456:item789^key000:');
+    });
+  });
+
+  describe('round-trip serialization', () => {
+    const testCases = [
+      'annotation:my-app:versionId:::',
+      'annotation:my-app:versionId:::revision',
+      'annotation:my-app:versionId:module::',
+      'annotation:my-app:versionId:module::revision',
+      'annotation:my-app:versionId:module:someKey:',
+      'annotation:my-app:versionId:module:someItem^someKey:',
+      'annotation:my-app:versionId:module:someItem^someKey:revision',
+      'annotation:my-app:versionId:module:aDifferentKey:revision',
+      'label:myapp:v2:config:dbUrl:',
+      'label:myapp:v2:config:database^url:',
+      'annotation:app:v1:::rev1',
+      'annotation:my-app_test:v1.2.3:auth-module:api_key:',
+      'label:app123:v2:module456:item789^key000:',
+      'annotation:app:v1:auth:secretKey:abc123def456ghi789',
+      'annotation:app:v1:auth:user^:',
+    ];
+
+    testCases.forEach((mrn) => {
+      it(`should round-trip serialize/parse for: ${mrn}`, () => {
+        const parsed = parseMRN(mrn);
+        const serialized = serializeMRN(parsed);
+        expect(serialized).toBe(mrn);
+
+        // Double check by parsing the serialized result
+        const reparsed = parseMRN(serialized);
+        expect(reparsed).toEqual(parsed);
+      });
+    });
+  });
+
+  describe('parsePartialMRN', () => {
+    describe('partial MRN parsing for prefixes', () => {
+      it('should parse type only', () => {
+        const result = parsePartialMRN('annotation');
+        expect(result).toEqual({
+          type: 'annotation',
+        });
+      });
+
+      it('should parse type and applicationName', () => {
+        const result = parsePartialMRN('annotation:test-app');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+        });
+      });
+
+      it('should parse type, applicationName, and versionId', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+        });
+      });
+
+      it('should parse type, applicationName, versionId, and module', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0:auth');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+        });
+      });
+
+      it('should parse partial MRN with key only (no item)', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0:auth:secretKey');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          key: 'secretKey',
+          item: undefined,
+        });
+      });
+
+      it('should parse partial MRN with item and key using ^ separator', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0:auth:user^email');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+          key: 'email',
+        });
+      });
+
+      it('should parse partial MRN with item but empty key', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0:auth:user^');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+          key: '',
+        });
+      });
+
+      it('should parse full partial MRN with all components including revision', () => {
+        const result = parsePartialMRN('annotation:test-app:v1.0.0:auth:user^email:rev123');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+          key: 'email',
+          revision: 'rev123',
+        });
+      });
+
+      it('should handle label type', () => {
+        const result = parsePartialMRN('label:my-app:v2.0.0:config');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'my-app',
+          versionId: 'v2.0.0',
+          module: 'config',
+        });
+      });
+
+      it('should handle empty string', () => {
+        const result = parsePartialMRN('');
+        expect(result).toEqual({});
+      });
+
+      it('should handle single colon', () => {
+        const result = parsePartialMRN(':');
+        expect(result).toEqual({});
+      });
+
+      it('should handle multiple colons with empty values', () => {
+        const result = parsePartialMRN('annotation::');
+        expect(result).toEqual({
+          type: 'annotation',
+        });
+      });
+
+      it('should handle partial MRN with special characters', () => {
+        const result = parsePartialMRN('annotation:my-app_test:v1.2.3:auth-module');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app_test',
+          versionId: 'v1.2.3',
+          module: 'auth-module',
+        });
+      });
+
+      it('should handle partial MRN with numbers', () => {
+        const result = parsePartialMRN('label:app123:v2:module456');
+        expect(result).toEqual({
+          type: 'label',
+          applicationName: 'app123',
+          versionId: 'v2',
+          module: 'module456',
+        });
+      });
+    });
+
+    describe('edge cases and flexibility', () => {
+      it('should handle invalid type gracefully', () => {
+        const result = parsePartialMRN('invalid:test-app');
+        expect(result).toEqual({
+          type: 'invalid' as 'annotation' | 'label',
+          applicationName: 'test-app',
+        });
+      });
+
+      it('should handle partial MRN ending with colon', () => {
+        const result = parsePartialMRN('annotation:test-app:');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'test-app',
+        });
+      });
+
+      it('should handle partial MRN with only separators', () => {
+        const result = parsePartialMRN(':::');
+        expect(result).toEqual({});
+      });
+    });
+
+    describe('use cases for list operations', () => {
+      it('should support prefix matching for all annotations of an app', () => {
+        const result = parsePartialMRN('annotation:my-app');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+        });
+      });
+
+      it('should support prefix matching for all annotations of an app version', () => {
+        const result = parsePartialMRN('annotation:my-app:v1.0.0');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'v1.0.0',
+        });
+      });
+
+      it('should support prefix matching for all annotations in a module', () => {
+        const result = parsePartialMRN('annotation:my-app:v1.0.0:auth');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+        });
+      });
+
+      it('should support prefix matching for item-specific annotations', () => {
+        const result = parsePartialMRN('annotation:my-app:v1.0.0:auth:user^');
+        expect(result).toEqual({
+          type: 'annotation',
+          applicationName: 'my-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+          key: '',
+        });
+      });
+    });
+  });
+
+  describe('serializePartialMRN', () => {
+    describe('partial serialization', () => {
+      it('should serialize type only', () => {
+        const result = serializePartialMRN({ type: 'annotation' });
+        expect(result).toBe('annotation');
+      });
+
+      it('should serialize type and applicationName', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+        });
+        expect(result).toBe('annotation:test-app');
+      });
+
+      it('should serialize type, applicationName, and versionId', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0');
+      });
+
+      it('should serialize with module', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0:auth');
+      });
+
+      it('should serialize with key only (no item)', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          key: 'secretKey',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0:auth:secretKey');
+      });
+
+      it('should serialize with item and key using ^ separator', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+          key: 'email',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0:auth:user^email');
+      });
+
+      it('should serialize with item but no key', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          item: 'user',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0:auth:user^');
+      });
+
+      it('should serialize with revision', () => {
+        const result = serializePartialMRN({
+          type: 'annotation',
+          applicationName: 'test-app',
+          versionId: 'v1.0.0',
+          module: 'auth',
+          key: 'secretKey',
+          revision: 'rev123',
+        });
+        expect(result).toBe('annotation:test-app:v1.0.0:auth:secretKey:rev123');
+      });
+
+      it('should handle empty partial MRN', () => {
+        const result = serializePartialMRN({});
+        expect(result).toBe('');
+      });
+
+      it('should handle partial MRN with gaps', () => {
+        const result = serializePartialMRN({
+          type: 'label',
+          versionId: 'v1.0.0',
+          key: 'test-key',
+        });
+        expect(result).toBe('label:v1.0.0:test-key');
+      });
+
+      it('should handle label type', () => {
+        const result = serializePartialMRN({
+          type: 'label',
+          applicationName: 'my-app',
+          versionId: 'v2.0.0',
+          module: 'config',
+        });
+        expect(result).toBe('label:my-app:v2.0.0:config');
+      });
+    });
+
+    describe('round-trip with parsePartialMRN', () => {
+      const testCases = [
+        'annotation',
+        'annotation:test-app',
+        'annotation:test-app:v1.0.0',
+        'annotation:test-app:v1.0.0:auth',
+        'annotation:test-app:v1.0.0:auth:secretKey',
+        'annotation:test-app:v1.0.0:auth:user^email',
+        'annotation:test-app:v1.0.0:auth:user^',
+        'label:my-app:v2.0.0:config',
+      ];
+
+      testCases.forEach((partialMrn) => {
+        it(`should round-trip serialize/parse for: ${partialMrn}`, () => {
+          const parsed = parsePartialMRN(partialMrn);
+          const serialized = serializePartialMRN(parsed);
+          expect(serialized).toBe(partialMrn);
+
+          // Double check by parsing the serialized result
+          const reparsed = parsePartialMRN(serialized);
+          expect(reparsed).toEqual(parsed);
+        });
+      });
+    });
+  });
+});