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

package/src/app/registration/schema.test.ts.bak

@@ -0,0 +1,308 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  type Registration,
+  type RegistrationPayload,
+  RegistrationPayloadSchema,
+  RegistrationSchema,
+  UpsertRegistrationPayloadSchema,
+} from './schema.js';
+
+describe('App Registration - Schema', () => {
+  describe('RegistrationSchema', () => {
+    test('should accept complete registration object', () => {
+      const registration = {
+        allowSelfRegistration: true,
+        updatedAt: new Date(),
+        deletedAt: new Date(),
+        deactivatedAt: new Date(),
+        metadata: {
+          approval_required: false,
+          email_verification: true,
+          default_role: 'user',
+        },
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal registration object', () => {
+      const registration = {
+        metadata: {},
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+      // Should have default allowSelfRegistration value
+      expect((result as Registration).allowSelfRegistration).toBe(false);
+    });
+
+    test('should accept registration with allowSelfRegistration false', () => {
+      const registration = {
+        allowSelfRegistration: false,
+        metadata: {
+          registration_flow: 'invite_only',
+          admin_approval: true,
+        },
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as Registration).allowSelfRegistration).toBe(false);
+    });
+
+    test('should accept registration with allowSelfRegistration true', () => {
+      const registration = {
+        allowSelfRegistration: true,
+        updatedAt: new Date(),
+        metadata: {
+          registration_flow: 'open',
+          email_domains: ['example.com', 'company.org'],
+          require_email_verification: true,
+        },
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as Registration).allowSelfRegistration).toBe(true);
+    });
+
+    test('should accept registration with optional dates', () => {
+      const registration = {
+        allowSelfRegistration: true,
+        updatedAt: new Date(),
+        metadata: {
+          last_config_change: new Date().toISOString(),
+          configured_by: 'admin@example.com',
+        },
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept registration with complex metadata', () => {
+      const registration = {
+        allowSelfRegistration: true,
+        updatedAt: new Date(),
+        deletedAt: new Date(),
+        metadata: {
+          settings: {
+            email_verification_required: true,
+            phone_verification_required: false,
+            captcha_required: true,
+            password_policy: {
+              min_length: 8,
+              require_uppercase: true,
+              require_lowercase: true,
+              require_numbers: true,
+              require_symbols: false,
+            },
+          },
+          restrictions: {
+            allowed_domains: ['company.com', 'partner.org'],
+            blocked_domains: ['tempmail.com', 'guerrillamail.info'],
+            max_registrations_per_day: 100,
+            rate_limit_per_ip: 5,
+          },
+          workflow: {
+            approval_workflow: false,
+            auto_assign_role: 'member',
+            welcome_email: true,
+            onboarding_flow: 'standard',
+          },
+        },
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid allowSelfRegistration type', () => {
+      const registration = {
+        allowSelfRegistration: 'yes', // should be boolean
+        metadata: {},
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid date types', () => {
+      const registration = {
+        allowSelfRegistration: true,
+        updatedAt: 'invalid-date',
+        metadata: {},
+      };
+
+      const result = RegistrationSchema(registration);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('RegistrationPayloadSchema', () => {
+    test('should accept complete payload', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {
+          configuration: 'open_registration',
+          updated_by: 'admin@example.com',
+        },
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept minimal payload', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as RegistrationPayload).allowSelfRegistration).toBe(false);
+    });
+
+    test('should accept payload with allowSelfRegistration', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        metadata: {
+          feature_enabled: true,
+          enabled_at: new Date().toISOString(),
+        },
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        allowSelfRegistration: false,
+        updatedAt: new Date().toISOString(),
+        metadata: {
+          disabled_reason: 'maintenance',
+          re_enable_at: new Date().toISOString(),
+        },
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept payload with comprehensive registration settings', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        updatedAt: new Date().toISOString(),
+        metadata: {
+          email_format: 'strict',
+          name_min_length: 2,
+          phone_format: 'international',
+        },
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid date format', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        updatedAt: 'invalid-date',
+        metadata: {},
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid allowSelfRegistration type', () => {
+      const payload = {
+        allowSelfRegistration: 'true', // should be boolean
+        metadata: {},
+      };
+
+      const result = RegistrationPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpsertRegistrationPayloadSchema', () => {
+    test('should accept upsert with allowSelfRegistration', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        metadata: {
+          operation: 'enable_self_registration',
+          reason: 'open_beta_launch',
+        },
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept upsert without allowSelfRegistration', () => {
+      const payload = {
+        metadata: {
+          operation: 'enable_self_registration',
+          reason: 'open_beta_launch',
+        },
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept upsert with undefined allowSelfRegistration', () => {
+      const payload = {
+        allowSelfRegistration: undefined,
+        metadata: {
+          partial_update: true,
+        },
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept empty metadata', () => {
+      const payload = {
+        allowSelfRegistration: false,
+        metadata: {},
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept comprehensive upsert payload', () => {
+      const payload = {
+        allowSelfRegistration: true,
+        metadata: {
+          updated_by: 'admin@example.com',
+          change_reason: 'platform_upgrade',
+        },
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid allowSelfRegistration type', () => {
+      const payload = {
+        allowSelfRegistration: 'maybe', // should be boolean or undefined
+        metadata: {},
+      };
+
+      const result = UpsertRegistrationPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

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

@@ -0,0 +1,221 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  type AppAssociationReference,
+  AppAssociationReferenceSchema,
+  AppIdPropertySchema,
+  AppIdSchema,
+  AppSchema,
+  AppStatus,
+  UpdateAppPayloadSchema,
+} from './schema.js';
+import { generateAppId } from './utils.js';
+
+describe('App - Schema', () => {
+  describe('AppStatus constants', () => {
+    test('should have correct status values', () => {
+      expect(AppStatus.ENABLED).toBe('enabled');
+      expect(AppStatus.DISABLED).toBe('disabled');
+    });
+  });
+
+  describe('AppIdSchema', () => {
+    test('should accept valid app ID', () => {
+      const id = generateAppId();
+      const result = AppIdSchema(id);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe(id);
+    });
+
+    test('should reject invalid app ID format', () => {
+      expect(AppIdSchema('invalid_id')).toBeInstanceOf(type.errors);
+      expect(AppIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(AppIdSchema(123)).toBeInstanceOf(type.errors);
+      expect(AppIdSchema(null)).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('AppIdPropertySchema', () => {
+    test('should accept valid id property', () => {
+      const payload = { id: generateAppId() };
+      const result = AppIdPropertySchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject missing id', () => {
+      const result = AppIdPropertySchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid id format', () => {
+      const result = AppIdPropertySchema({ id: 'invalid_id' });
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('AppSchema', () => {
+    test('should accept complete app object', () => {
+      const app = {
+        id: generateAppId(),
+        status: 'enabled' as const,
+        label: 'My Application',
+        description: 'Application description',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: { key: 'value' },
+      };
+
+      const result = AppSchema(app);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal app object', () => {
+      const app = {
+        id: generateAppId(),
+        status: 'enabled' as const,
+        label: 'Simple App',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = AppSchema(app);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept app with optional dates', () => {
+      const app = {
+        id: generateAppId(),
+        status: 'disabled' as const,
+        label: 'Disabled App',
+        description: 'This app is disabled',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: new Date(),
+        deactivatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = AppSchema(app);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid status', () => {
+      const app = {
+        id: generateAppId(),
+        status: 'invalid-status',
+        label: 'My App',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = AppSchema(app);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const app = {
+        id: generateAppId(),
+        status: 'enabled' as const,
+        // missing label, createdAt, updatedAt, metadata
+      };
+
+      const result = AppSchema(app);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpdateAppPayloadSchema', () => {
+    test('should accept all optional fields', () => {
+      const payload = {
+        status: 'disabled' as const,
+        label: 'Updated App',
+        description: 'Updated description',
+        metadata: { updated: true },
+      };
+
+      const result = UpdateAppPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept empty update payload', () => {
+      const result = UpdateAppPayloadSchema({});
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({});
+    });
+
+    test('should accept partial updates', () => {
+      const payload = { label: 'New Label' };
+      const result = UpdateAppPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept null values for nullable fields', () => {
+      const payload = {
+        label: null,
+        description: null,
+      };
+
+      const result = UpdateAppPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid status', () => {
+      const payload = { status: 'invalid-status' };
+      const result = UpdateAppPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('AppAssociationReferenceSchema', () => {
+    test('should accept complete association reference', () => {
+      const reference = {
+        id: generateAppId(),
+        status: 'enabled' as const,
+        label: 'Associated App',
+        model: 'App' as const,
+      };
+
+      const result = AppAssociationReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(reference);
+    });
+
+    test('should use default status when not provided', () => {
+      const reference = {
+        id: generateAppId(),
+        label: 'Test App',
+        model: 'App' as const,
+      };
+
+      const result = AppAssociationReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as AppAssociationReference).status).toBe('disabled'); // default value
+    });
+
+    test('should reject missing required fields', () => {
+      const reference = { id: generateAppId() };
+      const result = AppAssociationReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid model value', () => {
+      const reference = {
+        id: generateAppId(),
+        label: 'Test App',
+        model: 'InvalidModel',
+      };
+
+      const result = AppAssociationReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

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

@@ -0,0 +1,148 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../app/utils.js';
+import {
+  generatePermissionId,
+  generateRoleId,
+} from '../authorization/schema.js';
+import { generateUserId } from '../customer/schema.js';
+import {
+  AssociationObjectType,
+  AssociationIdReferenceSchema,
+  AssociationAttributesReferenceSchema,
+  AssociationObjectSchema,
+} from './schema.js';
+
+describe('Association - Schema', () => {
+  describe('AssociationObjectType constants', () => {
+    test('should have correct object type values', () => {
+      expect(AssociationObjectType.USER).toBe('User');
+      expect(AssociationObjectType.ORGANIZATION).toBe('Organization');
+      expect(AssociationObjectType.ROLE).toBe('Role');
+      expect(AssociationObjectType.APP).toBe('App');
+      expect(AssociationObjectType.PERMISSION).toBe('Permission');
+    });
+  });
+
+  describe('AssociationIdReferenceSchema', () => {
+    test('should accept valid id reference', () => {
+      const reference = { id: 'any_string_id' };
+      const result = AssociationIdReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(reference);
+    });
+
+    test('should reject missing id', () => {
+      const result = AssociationIdReferenceSchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string id', () => {
+      const reference = { id: 123 };
+      const result = AssociationIdReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('AssociationAttributesReferenceSchema', () => {
+    test('should accept id with additional attributes', () => {
+      const reference = {
+        id: 'test_id',
+        name: 'Test Name',
+        status: 'active',
+        metadata: { key: 'value' },
+      };
+
+      const result = AssociationAttributesReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(reference);
+    });
+
+    test('should accept minimal reference with just id', () => {
+      const reference = { id: 'minimal_id' };
+      const result = AssociationAttributesReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(reference);
+    });
+
+    test('should reject missing id', () => {
+      const reference = { name: 'Test', status: 'active' };
+      const result = AssociationAttributesReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('AssociationObjectSchema', () => {
+    // Note: User association reference has complex requirements
+    // that depend on UserNamePropertiesSchema and EmailOrPhonePropertiesSchema
+
+    test('should accept App association reference', () => {
+      const appAssociation = {
+        id: generateAppId(),
+        status: 'enabled' as const,
+        label: 'Test App',
+        model: 'App' as const,
+      };
+
+      const result = AssociationObjectSchema(appAssociation);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept Role association reference', () => {
+      const roleAssociation = {
+        id: generateRoleId(),
+        name: 'admin',
+        status: 'enabled' as const,
+        model: 'Role' as const,
+      };
+
+      const result = AssociationObjectSchema(roleAssociation);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept Permission association reference', () => {
+      const permissionAssociation = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'enabled' as const,
+        model: 'Permission' as const,
+      };
+
+      const result = AssociationObjectSchema(permissionAssociation);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid association object', () => {
+      const invalidAssociation = {
+        id: 'test_id',
+        name: 'Test',
+        model: 'InvalidModel',
+      };
+
+      const result = AssociationObjectSchema(invalidAssociation);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject association missing required fields', () => {
+      const incompleteAssociation = {
+        id: generateUserId(),
+        // missing required fields for any valid association type
+      };
+
+      const result = AssociationObjectSchema(incompleteAssociation);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject association with mismatched model and data', () => {
+      const mismatchedAssociation = {
+        id: generateUserId(),
+        name: 'admin', // role field
+        status: 'enabled' as const,
+        model: 'User' as const, // but missing user fields
+      };
+
+      const result = AssociationObjectSchema(mismatchedAssociation);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});