@go-mondo/identity-sdk 0.0.2-beta.7 → 0.0.2-beta.71

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();
+    });
+  });
+});

package/src/customer/users/schema.test.ts.bak

@@ -0,0 +1,138 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../schema.js';
+import {
+  InsertUserPayloadSchema,
+  UserPayloadSchema,
+  UserStatus,
+} from './schema.js';
+
+describe('Customer - User', () => {
+  describe('User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        status: UserStatus.ACTIVE,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      const result = UserPayloadSchema(
+        item
+      ) as typeof UserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+    });
+  });
+
+  describe('Insert User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        familyName: 'Foo',
+        phoneNumber: '123',
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+      expect(result?.familyName).to.equal(item.familyName);
+    });
+
+    test('should serialize successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        metadata: new Map(),
+        // status: UserStatus.ACTIVE,
+        // createdAt: new Date(),
+        // updatedAt: new Date(),
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.null;
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const test = type({
+        foo: 'string.numeric.parse',
+        bar: 'number',
+        baz: 'string.date.iso.parse',
+      });
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { IdentityIdentifier, IdentityIdentifierSchema } from './schema.js';
+
+describe('Identity - Schema', () => {
+  describe('IdentityIdentifier constants', () => {
+    test('should have correct identifier values', () => {
+      expect(IdentityIdentifier.EMAIL).toBe('email');
+      expect(IdentityIdentifier.PHONE_NUMBER).toBe('phoneNumber');
+    });
+  });
+
+  describe('IdentityIdentifierSchema', () => {
+    test('should accept valid email identifier', () => {
+      const result = IdentityIdentifierSchema('email');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('email');
+    });
+
+    test('should accept valid phone number identifier', () => {
+      const result = IdentityIdentifierSchema('phoneNumber');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('phoneNumber');
+    });
+
+    test('should reject invalid identifiers', () => {
+      expect(IdentityIdentifierSchema('username')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('invalid')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(IdentityIdentifierSchema(123)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(null)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(undefined)).toBeInstanceOf(type.errors);
+    });
+
+    test('should be case sensitive', () => {
+      expect(IdentityIdentifierSchema('Email')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('PHONE_NUMBER')).toBeInstanceOf(
+        type.errors
+      );
+      expect(IdentityIdentifierSchema('phonenumber')).toBeInstanceOf(
+        type.errors
+      );
+    });
+  });
+});

package/src/oauth/token/schema/schema.test.ts.bak

@@ -0,0 +1,142 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { Schema } from './schema.js';
+
+describe('OAuth Token - Schema', () => {
+  describe('Schema union', () => {
+    test('should accept authorization code grant', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with PKCE', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+        code_verifier: 'pkce_verifier_123',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with client secret', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept client credentials grant', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read write',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept refresh token grant', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        refresh_token: 'refresh_token_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid grant type', () => {
+      const payload = {
+        grant_type: 'invalid_grant',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject authorization code without required fields', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        client_id: generateAppId(),
+        // missing code and redirect_uri
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid redirect URI', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'not-a-valid-url',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject client credentials without required fields', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        // missing client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject refresh token without required fields', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        client_id: 'app_123',
+        // missing refresh_token and client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject completely invalid payload', () => {
+      const payload = {
+        invalid: 'data',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});