@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

package/src/common/schema/collection.test.ts.bak

@@ -0,0 +1,116 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { CollectionSchema, PaginationCollectionSchema } from './collection.js';
+
+describe('Common Schema - Collection', () => {
+  describe('CollectionSchema', () => {
+    test('should accept valid collection with string items', () => {
+      const StringCollectionSchema = CollectionSchema('string');
+      const result = StringCollectionSchema({
+        items: ['item1', 'item2', 'item3'],
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: ['item1', 'item2', 'item3'],
+      });
+    });
+
+    test('should accept valid collection with number items', () => {
+      const NumberCollectionSchema = CollectionSchema('number');
+      const result = NumberCollectionSchema({
+        items: [1, 2, 3],
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: [1, 2, 3],
+      });
+    });
+
+    test('should accept empty collection', () => {
+      const StringCollectionSchema = CollectionSchema('string');
+      const result = StringCollectionSchema({
+        items: [],
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: [],
+      });
+    });
+
+    test('should reject invalid items type', () => {
+      const StringCollectionSchema = CollectionSchema('string');
+      const result = StringCollectionSchema({
+        items: 'not-an-array',
+      });
+
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('PaginationCollectionSchema', () => {
+    test('should accept valid paginated collection', () => {
+      const StringPaginationCollectionSchema =
+        PaginationCollectionSchema('string');
+      const result = StringPaginationCollectionSchema({
+        items: ['item1', 'item2'],
+        pagination: {
+          pageSize: '10',
+          nextToken: 'token123',
+        },
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: ['item1', 'item2'],
+        pagination: {
+          pageSize: '10',
+          nextToken: 'token123',
+        },
+      });
+    });
+
+    test('should accept collection without pagination', () => {
+      const StringPaginationCollectionSchema =
+        PaginationCollectionSchema('string');
+      const result = StringPaginationCollectionSchema({
+        items: ['item1', 'item2'],
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: ['item1', 'item2'],
+      });
+    });
+
+    test('should accept collection with empty pagination', () => {
+      const StringPaginationCollectionSchema =
+        PaginationCollectionSchema('string');
+      const result = StringPaginationCollectionSchema({
+        items: ['item1'],
+        pagination: {},
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        items: ['item1'],
+        pagination: {},
+      });
+    });
+
+    test('should reject invalid pagination', () => {
+      const StringPaginationCollectionSchema =
+        PaginationCollectionSchema('string');
+      const result = StringPaginationCollectionSchema({
+        items: ['item1'],
+        pagination: {
+          pageSize: true,
+        },
+      });
+
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/common/schema/dates.test.ts.bak

@@ -0,0 +1,49 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
+
+describe('Common - Dates', () => {
+  describe('Date Schema', () => {
+    test('should accept an iso string', async () => {
+      const result = RequiredDateSchema(
+        new Date().toISOString()
+      ) as typeof RequiredDateSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Date);
+    });
+
+    test('should accept a Date object', async () => {
+      const result = RequiredDateSchema(
+        new Date()
+      ) as typeof RequiredDateSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('Payload Schema', () => {
+    test('should parse a Date to an ISO string', async () => {
+      const iso = new Date().toISOString();
+
+      const result = RequiredDatePayloadSchema(
+        new Date(iso)
+      ) as typeof RequiredDatePayloadSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).to.equal(iso);
+    });
+
+    test('should parse an ISO to an ISO string', async () => {
+      const iso = new Date().toISOString();
+
+      const result = RequiredDatePayloadSchema(
+        iso
+      ) as typeof RequiredDatePayloadSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).to.equal(iso);
+    });
+  });
+});

package/src/common/schema/id.test.ts.bak

@@ -0,0 +1,149 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { KSUIDSchema } from './id.js';
+
+describe('Common Schema - ID', () => {
+  describe('KSUIDSchema', () => {
+    test('should accept valid KSUID with correct prefix', () => {
+      const schema = KSUIDSchema('usr');
+      const validId = 'usr_123456789012345678901234567';
+
+      const result = schema(validId);
+      expect(result).toBe(validId);
+    });
+
+    test('should accept KSUID with different prefixes', () => {
+      const userSchema = KSUIDSchema('usr');
+      const appSchema = KSUIDSchema('app');
+      const activitySchema = KSUIDSchema('act');
+
+      const userId = 'usr_abcdefghijklmnopqrstuvwxy12';
+      const appId = 'app_1234567890ABCDEFGHIJKLMNOP1';
+      const activityId = 'act_abcDEF123456789012345678901';
+
+      expect(userSchema(userId)).toBe(userId);
+      expect(appSchema(appId)).toBe(appId);
+      expect(activitySchema(activityId)).toBe(activityId);
+    });
+
+    test('should accept KSUID with mixed alphanumeric characters', () => {
+      const schema = KSUIDSchema('test');
+      const mixedId = 'test_1a2B3c4D5e6F7g8H9i0JkLmNoPq';
+
+      const result = schema(mixedId);
+      expect(result).toBe(mixedId);
+    });
+
+    test('should reject KSUID with wrong prefix', () => {
+      const schema = KSUIDSchema('usr');
+      const wrongPrefixId = 'app_123456789012345678901234567';
+
+      const result = schema(wrongPrefixId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with missing prefix', () => {
+      const schema = KSUIDSchema('usr');
+      const noPrefixId = '123456789012345678901234567';
+
+      const result = schema(noPrefixId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with missing underscore', () => {
+      const schema = KSUIDSchema('usr');
+      const noUnderscoreId = 'usr123456789012345678901234567';
+
+      const result = schema(noUnderscoreId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with incorrect suffix length (too short)', () => {
+      const schema = KSUIDSchema('usr');
+      const shortId = 'usr_12345678901234567890123456';
+
+      const result = schema(shortId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with incorrect suffix length (too long)', () => {
+      const schema = KSUIDSchema('usr');
+      const longId = 'usr_1234567890123456789012345678';
+
+      const result = schema(longId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with invalid characters in suffix', () => {
+      const schema = KSUIDSchema('usr');
+      const invalidCharsId = 'usr_123456789012345678901234_*';
+
+      const result = schema(invalidCharsId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with special characters in suffix', () => {
+      const schema = KSUIDSchema('usr');
+      const specialCharsId = 'usr_12345678901234567890123456@';
+
+      const result = schema(specialCharsId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject KSUID with spaces', () => {
+      const schema = KSUIDSchema('usr');
+      const spaceId = 'usr_1234567890123456789012345 7';
+
+      const result = schema(spaceId);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject empty string', () => {
+      const schema = KSUIDSchema('usr');
+
+      const result = schema('');
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      const schema = KSUIDSchema('usr');
+
+      expect(schema(123)).toBeInstanceOf(type.errors);
+      expect(schema(null)).toBeInstanceOf(type.errors);
+      expect(schema(undefined)).toBeInstanceOf(type.errors);
+      expect(schema({})).toBeInstanceOf(type.errors);
+    });
+
+    test('should work with complex prefixes', () => {
+      const complexSchema = KSUIDSchema('app_config');
+      const validComplexId = 'app_config_123456789012345678901234567';
+
+      const result = complexSchema(validComplexId);
+      expect(result).toBe(validComplexId);
+    });
+
+    test('should work with single character prefix', () => {
+      const singleCharSchema = KSUIDSchema('a');
+      const validSingleCharId = 'a_123456789012345678901234567';
+
+      const result = singleCharSchema(validSingleCharId);
+      expect(result).toBe(validSingleCharId);
+    });
+
+    test('should create different schemas for different prefixes', () => {
+      const userSchema = KSUIDSchema('usr');
+      const orgSchema = KSUIDSchema('org');
+
+      const userId = 'usr_123456789012345678901234567';
+      const orgId = 'org_123456789012345678901234567';
+
+      // User schema should accept user ID but reject org ID
+      expect(userSchema(userId)).toBe(userId);
+      expect(userSchema(orgId)).toBeInstanceOf(type.errors);
+
+      // Org schema should accept org ID but reject user ID
+      expect(orgSchema(orgId)).toBe(orgId);
+      expect(orgSchema(userId)).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/common/schema/jwt.test.ts.bak

@@ -0,0 +1,61 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { Algorithm, AlgorithmSchema } from './jwt.js';
+
+describe('Common Schema - JWT', () => {
+  describe('Algorithm constants', () => {
+    test('should have correct algorithm values', () => {
+      expect(Algorithm.DEFAULT).toBe('RS256');
+      expect(Algorithm.HS256).toBe('HS256');
+      expect(Algorithm.HS384).toBe('HS384');
+      expect(Algorithm.HS512).toBe('HS512');
+      expect(Algorithm.RS256).toBe('RS256');
+      expect(Algorithm.RS384).toBe('RS384');
+      expect(Algorithm.RS512).toBe('RS512');
+      expect(Algorithm.ES256).toBe('ES256');
+      expect(Algorithm.ES384).toBe('ES384');
+      expect(Algorithm.ES512).toBe('ES512');
+      expect(Algorithm.PS256).toBe('PS256');
+      expect(Algorithm.PS384).toBe('PS384');
+      expect(Algorithm.PS512).toBe('PS512');
+    });
+  });
+
+  describe('AlgorithmSchema', () => {
+    test('should accept valid HMAC algorithms', () => {
+      expect(AlgorithmSchema('HS256')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('HS384')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('HS512')).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept valid RSA algorithms', () => {
+      expect(AlgorithmSchema('RS256')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('RS384')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('RS512')).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept valid ECDSA algorithms', () => {
+      expect(AlgorithmSchema('ES256')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('ES384')).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept valid PSS algorithms', () => {
+      expect(AlgorithmSchema('PS256')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('PS384')).not.toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('PS512')).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid algorithms', () => {
+      expect(AlgorithmSchema('INVALID')).toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('HS128')).toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('RS128')).toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema('')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(AlgorithmSchema(123)).toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema(null)).toBeInstanceOf(type.errors);
+      expect(AlgorithmSchema(undefined)).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/common/schema/metadata.test.ts.bak

@@ -0,0 +1,141 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  MetadataMapPropertySchema,
+  MetadataPayloadPropertySchema,
+  UpsertMetadataPayloadSchema,
+} from './metadata.js';
+
+describe('Common - Metadata', () => {
+  describe('Map Property Schema', () => {
+    test('should parse a record to a map', async () => {
+      const result = MetadataMapPropertySchema({
+        metadata: { foo: 'bar' },
+      }) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).toBeInstanceOf(Map);
+    });
+
+    test('should parse undefined property to a map', async () => {
+      const result = MetadataMapPropertySchema({
+        metadata: undefined,
+      }) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).toBeInstanceOf(Map);
+    });
+
+    test('should parse undefined to a map', async () => {
+      const result = MetadataMapPropertySchema(
+        {}
+      ) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).toBeInstanceOf(Map);
+    });
+
+    test('should parse map to a map', async () => {
+      const result = MetadataMapPropertySchema({
+        metadata: new Map([['foo', 'bar']]),
+      }) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).toBeInstanceOf(Map);
+    });
+
+    test('should parse null to a map', async () => {
+      const result = MetadataMapPropertySchema({
+        metadata: null,
+      }) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).toBeInstanceOf(Map);
+    });
+  });
+
+  describe('Payload', () => {
+    test('should parse map to record', async () => {
+      const result = MetadataPayloadPropertySchema({
+        metadata: new Map<string, string | number>([
+          ['foo', 'bar'],
+          ['baz', 0],
+        ]),
+      }) as typeof MetadataPayloadPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata?.foo).to.equal('bar');
+      expect(result?.metadata?.baz).to.equal(0);
+    });
+
+    test('should return undefined if map is empty', async () => {
+      const result = MetadataPayloadPropertySchema({
+        metadata: new Map(),
+      }) as typeof MetadataPayloadPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).is.undefined;
+    });
+  });
+
+  describe('Upsert Metadata Payload Schema', () => {
+    test('should handle incoming record', async () => {
+      const result = UpsertMetadataPayloadSchema({
+        foo: 'bar',
+        bar: 'baz',
+      }) as typeof UpsertMetadataPayloadSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.foo).to.equal('bar');
+      expect(result?.bar).to.equal('baz');
+    });
+
+    test('should handle incoming map', async () => {
+      const result = UpsertMetadataPayloadSchema(
+        new Map([
+          ['foo', 'bar'],
+          ['bar', 'baz'],
+        ])
+      ) as typeof UpsertMetadataPayloadSchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.foo).to.equal('bar');
+      expect(result?.bar).to.equal('baz');
+    });
+
+    test('should only allow 10 items', async () => {
+      const result = UpsertMetadataPayloadSchema(
+        new Map([
+          ['1', '1'],
+          ['2', '2'],
+          ['3', '3'],
+          ['4', '4'],
+          ['5', '5'],
+          ['6', '6'],
+          ['7', '7'],
+          ['8', '8'],
+          ['9', '9'],
+          ['10', '10'],
+          ['11', '11'],
+        ])
+      ) as typeof UpsertMetadataPayloadSchema.inferOut;
+
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('Map Property Schema', () => {
+    test('should parse map to record', async () => {
+      const result = MetadataMapPropertySchema({
+        metadata: {
+          foo: 'bar',
+          bar: 'baz',
+        },
+      }) as typeof MetadataMapPropertySchema.inferOut;
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata?.get('foo')).to.equal('bar');
+      expect(result?.metadata?.get('bar')).to.equal('baz');
+    });
+  });
+});

package/src/common/schema/pagination.test.ts.bak

@@ -0,0 +1,80 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { PaginationSchema } from './pagination.js';
+
+describe('Common Schema - Pagination', () => {
+  describe('PaginationSchema', () => {
+    test('should accept valid pagination with pageSize as string', () => {
+      const result = PaginationSchema({
+        pageSize: '10',
+        nextToken: 'token123',
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        pageSize: '10',
+        nextToken: 'token123',
+      });
+    });
+
+    test('should accept valid pagination with pageSize as number', () => {
+      const result = PaginationSchema({
+        pageSize: 20,
+        nextToken: 'token456',
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        pageSize: 20,
+        nextToken: 'token456',
+      });
+    });
+
+    test('should accept pagination with only pageSize', () => {
+      const result = PaginationSchema({
+        pageSize: '15',
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        pageSize: '15',
+      });
+    });
+
+    test('should accept pagination with only nextToken', () => {
+      const result = PaginationSchema({
+        nextToken: 'token789',
+      });
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        nextToken: 'token789',
+      });
+    });
+
+    test('should accept empty pagination object', () => {
+      const result = PaginationSchema({});
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({});
+    });
+
+    test('should reject invalid pageSize type', () => {
+      const result = PaginationSchema({
+        pageSize: true,
+        nextToken: 'token123',
+      });
+
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid nextToken type', () => {
+      const result = PaginationSchema({
+        pageSize: '10',
+        nextToken: 123,
+      });
+
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/common/schema/schema.test.ts.bak

@@ -0,0 +1,41 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { optionallyNullishToUndefined } from './schema.js';
+
+describe('Common Schema', () => {
+  describe('optionallyNullishToUndefined', () => {
+    test('should parse null string successfully', async () => {
+      const Schema = type({
+        foo: optionallyNullishToUndefined(type('string')),
+      });
+
+      const result = Schema.assert({
+        foo: null,
+      });
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result.foo).toBeUndefined();
+    });
+
+    test('should parse undefined string successfully', async () => {
+      const Schema = type({
+        foo: optionallyNullishToUndefined(type('string')),
+      });
+
+      const result = Schema.assert({
+        foo: undefined,
+      });
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result.foo).toBeUndefined();
+    });
+  });
+});