@go-mondo/identity-sdk 0.0.2-beta.3 → 0.0.2-beta.31

package/src/action/schema/base.test.ts.bak

@@ -0,0 +1,152 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  ActionOperation,
+  ActionIdSchema,
+  ActionIdPropertySchema,
+  OperationSchema,
+  BasePayloadSchema,
+} from './base.js';
+import { generateActionId } from './utils.js';
+
+describe('Action Schema - Base', () => {
+  describe('ActionOperation constants', () => {
+    test('should have correct operation values', () => {
+      expect(ActionOperation.SET_PASSWORD).toBe('set-password');
+      expect(ActionOperation.USER_ATTRIBUTE_VERIFICATION).toBe(
+        'user-attribute-verification'
+      );
+      expect(ActionOperation.SIGN_UP).toBe('sign-up');
+      expect(ActionOperation.SIGN_UP_VERIFICATION).toBe('sign-up-verification');
+    });
+  });
+
+  describe('ActionIdSchema', () => {
+    test('should accept valid action ID', () => {
+      const id = generateActionId();
+      const result = ActionIdSchema(id);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe(id);
+    });
+
+    test('should reject invalid action ID format', () => {
+      expect(ActionIdSchema('invalid_id')).toBeInstanceOf(type.errors);
+      expect(ActionIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(ActionIdSchema(123)).toBeInstanceOf(type.errors);
+      expect(ActionIdSchema(null)).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('ActionIdPropertySchema', () => {
+    test('should accept valid id property', () => {
+      const payload = { id: generateActionId() };
+      const result = ActionIdPropertySchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject missing id', () => {
+      const result = ActionIdPropertySchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid id format', () => {
+      const result = ActionIdPropertySchema({ id: 'invalid_id' });
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('OperationSchema', () => {
+    test('should accept valid operations', () => {
+      expect(OperationSchema('sign-up')).not.toBeInstanceOf(type.errors);
+      expect(OperationSchema('sign-up-verification')).not.toBeInstanceOf(
+        type.errors
+      );
+      expect(OperationSchema('set-password')).not.toBeInstanceOf(type.errors);
+      expect(OperationSchema('user-attribute-verification')).not.toBeInstanceOf(
+        type.errors
+      );
+    });
+
+    test('should reject invalid operations', () => {
+      expect(OperationSchema('invalid-operation')).toBeInstanceOf(type.errors);
+      expect(OperationSchema('signup')).toBeInstanceOf(type.errors);
+      expect(OperationSchema('')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(OperationSchema(123)).toBeInstanceOf(type.errors);
+      expect(OperationSchema(null)).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('BasePayloadSchema', () => {
+    test('should accept complete base payload', () => {
+      const payload = {
+        id: generateActionId(),
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = BasePayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept base payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = BasePayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        attempt: 1,
+        // missing expiresAt, updatedAt, metadata
+      };
+
+      const result = BasePayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid attempt type', () => {
+      const payload = {
+        id: generateActionId(),
+        attempt: 'not-a-number',
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = BasePayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid date formats', () => {
+      const payload = {
+        id: generateActionId(),
+        attempt: 1,
+        expiresAt: 'invalid-date',
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = BasePayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/action/schema/operations/set-password.test.ts.bak

@@ -0,0 +1,197 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  SetPasswordActionPayloadSchema,
+  SetPasswordActionRequestSchema,
+} from './set-password.js';
+
+describe('Action Schema Operations - Set Password', () => {
+  describe('SetPasswordActionPayloadSchema', () => {
+    test('should accept complete payload with email identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        policy: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      // Policy defaults are applied, so we don't compare exact equality
+    });
+
+    test('should accept payload with phoneNumber identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        user: generateUserId(),
+        identifier: 'phoneNumber' as const,
+        policy: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      // Policy defaults are applied, so we don't compare exact equality
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        policy: {},
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: generateUserId(),
+        identifier: 'email' as const,
+        policy: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        user: generateUserId(),
+        identifier: 'username',
+        policy: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        // missing user, identifier, policy, etc.
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        policy: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = SetPasswordActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('SetPasswordActionRequestSchema', () => {
+    test('should accept valid request', () => {
+      const request = {
+        code: 'reset_code_123',
+        password: 'NewPassword123!',
+      };
+
+      const result = SetPasswordActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should reject missing code', () => {
+      const request = {
+        password: 'NewPassword123!',
+      };
+
+      const result = SetPasswordActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing password', () => {
+      const request = {
+        code: 'reset_code_123',
+      };
+
+      const result = SetPasswordActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      const request1 = {
+        code: 123456,
+        password: 'NewPassword123!',
+      };
+
+      const request2 = {
+        code: 'reset_code_123',
+        password: 123456,
+      };
+
+      expect(SetPasswordActionRequestSchema(request1)).toBeInstanceOf(
+        type.errors
+      );
+      expect(SetPasswordActionRequestSchema(request2)).toBeInstanceOf(
+        type.errors
+      );
+    });
+
+    test('should delete undeclared keys', () => {
+      const request = {
+        code: 'reset_code_123',
+        password: 'NewPassword123!',
+        extraField: 'should be removed',
+      };
+
+      const result = SetPasswordActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+      expect(result).toEqual({
+        code: 'reset_code_123',
+        password: 'NewPassword123!',
+      });
+    });
+  });
+});

package/src/action/schema/operations/sign-up-verification.test.ts.bak

@@ -0,0 +1,163 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  SignUpVerificationActionPayloadSchema,
+  SignUpVerificationActionRequestSchema,
+} from './sign-up-verification.js';
+
+describe('Action Schema Operations - Sign Up Verification', () => {
+  describe('SignUpVerificationActionPayloadSchema', () => {
+    test('should accept complete payload', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept phoneNumber identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'phoneNumber' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'username',
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        // missing user, identifier, etc.
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('SignUpVerificationActionRequestSchema', () => {
+    test('should accept valid request', () => {
+      const request = {
+        code: 'verification_code_123',
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should reject missing code', () => {
+      const result = SignUpVerificationActionRequestSchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string code', () => {
+      const request = {
+        code: 123456,
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const request = {
+        code: 'verification_code_123',
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+      expect(result).toEqual({ code: 'verification_code_123' });
+    });
+  });
+});