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

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

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

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

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