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

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

@@ -0,0 +1,203 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  SignUpActionPayloadSchema,
+  SignUpActionRequestSchema,
+} from './sign-up.js';
+
+describe('Action Schema Operations - Sign Up', () => {
+  describe('SignUpActionPayloadSchema', () => {
+    test('should accept complete payload with app', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        app: generateAppId(),
+        user: {
+          givenName: 'John',
+          familyName: 'Doe',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload without app', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {
+          givenName: 'Jane',
+          familyName: 'Smith',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal user name properties', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: { givenName: 'John' },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        // missing user, attempt, etc.
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: { givenName: 'John' },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('SignUpActionRequestSchema', () => {
+    test('should accept email sign up request', () => {
+      const request = {
+        id: generateUserId(),
+        email: 'john@example.com',
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept phone number sign up request', () => {
+      const request = {
+        id: generateUserId(),
+        phoneNumber: '+1234567890',
+        givenName: 'Jane',
+        familyName: 'Smith',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept request with both email and phone', () => {
+      const request = {
+        id: generateUserId(),
+        email: 'john@example.com',
+        phoneNumber: '+1234567890',
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept minimal request with just email', () => {
+      const request = {
+        email: 'minimal@example.com',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal request with just phone', () => {
+      const request = {
+        phoneNumber: '+1234567890',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject request without email or phone', () => {
+      const request = {
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid email format', () => {
+      const request = {
+        email: 'invalid-email',
+        givenName: 'John',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should accept optional name properties', () => {
+      const request = {
+        email: 'john@example.com',
+        givenName: 'John',
+        familyName: 'Doe',
+        middleName: 'Michael',
+        honorificPrefix: 'Dr.',
+        honorificSuffix: 'Jr.',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/action/schema/operations/user-attribute-verification.test.ts.bak

@@ -0,0 +1,148 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  UserAttributeVerificationActionPayloadSchema,
+  UserAttributeVerificationActionRequestSchema,
+} from './user-attribute-verification.js';
+
+describe('Action Schema Operations - User Attribute Verification', () => {
+  describe('UserAttributeVerificationActionPayloadSchema', () => {
+    test('should accept complete payload with email attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with phoneNumber attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'phoneNumber' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'username',
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        // missing user, attribute, attempt, etc.
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('UserAttributeVerificationActionRequestSchema', () => {
+    test('should accept empty request', () => {
+      const request = {};
+
+      const result = UserAttributeVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should delete undeclared keys', () => {
+      const request = {
+        extraField: 'should be removed',
+        anotherField: 'also removed',
+      };
+
+      const result = UserAttributeVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+      expect(result).not.toHaveProperty('anotherField');
+      expect(result).toEqual({});
+    });
+  });
+});

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

@@ -0,0 +1,218 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { ActionPayloadSchema, ActionOperation } from './schema.js';
+import { generateActionId } from './utils.js';
+import { generateUserId } from '../../customer/schema.js';
+
+describe('Action Schema - Main', () => {
+  describe('ActionPayloadSchema', () => {
+    test('should accept set-password action payload', () => {
+      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: { source: 'user-initiated' },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept sign-up-verification action 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: { method: 'email' },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept sign-up action payload', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {
+          firstName: 'John',
+          lastName: 'Doe',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { registration_source: 'web' },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept user-attribute-verification action payload', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { verification_type: 'change_email' },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid action operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject payload missing required fields for set-password', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'set-password' as const,
+        // missing password
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject payload missing required fields for sign-up-verification', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        // missing code
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject payload missing required fields for sign-up', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        // missing email
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject payload missing required fields for user-attribute-verification', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        attribute: 'email' as const,
+        // missing value and code
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should accept complex payloads with all optional fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {
+          firstName: 'John',
+          lastName: 'Doe',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {
+          source: 'mobile-app',
+          campaign: 'summer-2024',
+          referrer: 'friend-invitation',
+          terms_accepted: true,
+          marketing_consent: false,
+        },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept user-attribute-verification with phone attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'phoneNumber' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { verification_method: 'sms' },
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject malformed user data in sign-up action', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: 'invalid-user-data', // should be object
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid attribute type in user-attribute-verification', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'invalid_attribute',
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = ActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('ActionOperation constants', () => {
+    test('should contain expected operation values', () => {
+      expect(ActionOperation.SET_PASSWORD).toBe('set-password');
+      expect(ActionOperation.SIGN_UP_VERIFICATION).toBe('sign-up-verification');
+      expect(ActionOperation.SIGN_UP).toBe('sign-up');
+      expect(ActionOperation.USER_ATTRIBUTE_VERIFICATION).toBe(
+        'user-attribute-verification'
+      );
+    });
+  });
+});