@go-mondo/identity-sdk 0.0.2-beta.73 → 0.0.2-beta.75

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

@@ -1,61 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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);
-    });
-  });
-});