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

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

@@ -1,291 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { generateAppId } from '../../app/utils.js';
-import {
-  ActivityIdPropertySchema,
-  ActivityIdSchema,
-  ActivityType,
-  BaseInsertPayloadSchema,
-  BaseSchema,
-  BaseUpdatePayloadSchema,
-  PerformedBySchema,
-  PerformerType,
-  SourceSchema,
-} from './base.js';
-import { generateActivityId } from './utils.js';
-
-describe('Activity Schema - Base', () => {
-  describe('ActivityType constants', () => {
-    test('should have correct activity type values', () => {
-      expect(ActivityType.UNKNOWN).toBe('unknown');
-      expect(ActivityType.NOTE).toBe('note');
-      expect(ActivityType.OPERATION).toBe('operation');
-      expect(ActivityType.AUTHORIZATION).toBe('authorization');
-      expect(ActivityType.AUTHENTICATION).toBe('authentication');
-    });
-  });
-
-  describe('PerformerType constants', () => {
-    test('should have correct performer type values', () => {
-      expect(PerformerType.SYSTEM).toBe('system');
-      expect(PerformerType.GUEST).toBe('guest');
-      expect(PerformerType.IDENTITY).toBe('identity');
-      expect(PerformerType.AUTOMATION).toBe('automation');
-      expect(PerformerType.INTEGRATION).toBe('integration');
-    });
-  });
-
-  describe('ActivityIdSchema', () => {
-    test('should accept valid activity ID', () => {
-      const id = generateActivityId();
-      const result = ActivityIdSchema(id);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toBe(id);
-    });
-
-    test('should reject invalid activity ID format', () => {
-      expect(ActivityIdSchema('invalid_id')).toBeInstanceOf(type.errors);
-      expect(ActivityIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject non-string values', () => {
-      expect(ActivityIdSchema(123)).toBeInstanceOf(type.errors);
-      expect(ActivityIdSchema(null)).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('ActivityIdPropertySchema', () => {
-    test('should accept valid id property', () => {
-      const payload = { id: generateActivityId() };
-      const result = ActivityIdPropertySchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should reject missing id', () => {
-      const result = ActivityIdPropertySchema({});
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('SourceSchema', () => {
-    test('should accept string source', () => {
-      const result = SourceSchema('api-request');
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toBe('api-request');
-    });
-
-    test('should reject non-string values', () => {
-      expect(SourceSchema(123)).toBeInstanceOf(type.errors);
-      expect(SourceSchema(null)).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('PerformedBySchema', () => {
-    test('should accept valid performer with system type', () => {
-      const performer = {
-        type: 'system' as const,
-        identifier: 'system-process',
-      };
-
-      const result = PerformedBySchema(performer);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(performer);
-    });
-
-    test('should accept valid performer with identity type', () => {
-      const performer = {
-        type: 'identity' as const,
-        identifier: 'user@example.com',
-      };
-
-      const result = PerformedBySchema(performer);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(performer);
-    });
-
-    test('should accept all valid performer types', () => {
-      const types = [
-        'system',
-        'guest',
-        'identity',
-        'automation',
-        'integration',
-      ] as const;
-
-      for (const performerType of types) {
-        const performer = {
-          type: performerType,
-          identifier: `test-${performerType}`,
-        };
-        const result = PerformedBySchema(performer);
-        expect(result).not.toBeInstanceOf(type.errors);
-      }
-    });
-
-    test('should reject invalid performer type', () => {
-      const performer = {
-        type: 'invalid',
-        identifier: 'test',
-      };
-
-      const result = PerformedBySchema(performer);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject missing fields', () => {
-      expect(PerformedBySchema({ type: 'system' })).toBeInstanceOf(type.errors);
-      expect(PerformedBySchema({ identifier: 'test' })).toBeInstanceOf(
-        type.errors
-      );
-    });
-  });
-
-  describe('BaseSchema', () => {
-    test('should accept complete base activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        source: 'web-app',
-        app: generateAppId(),
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { key: 'value' },
-      };
-
-      const result = BaseSchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept activity without app', () => {
-      const activity = {
-        id: generateActivityId(),
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'background-job',
-        },
-        source: 'cron',
-        isMutateable: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = BaseSchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept activity with optional dates', () => {
-      const activity = {
-        id: generateActivityId(),
-        performedBy: {
-          type: 'guest' as const,
-          identifier: 'anonymous',
-        },
-        source: 'public-api',
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: new Date(),
-        deactivatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = BaseSchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject missing required fields', () => {
-      const activity = {
-        id: generateActivityId(),
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'test',
-        },
-        // missing source, isMutateable, dates, metadata
-      };
-
-      const result = BaseSchema(activity);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('BaseInsertPayloadSchema', () => {
-    test('should accept complete insert payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user123',
-        },
-        metadata: { source: 'api' },
-      };
-
-      const result = BaseInsertPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept minimal insert payload', () => {
-      const payload = {};
-
-      const result = BaseInsertPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      // Should generate default ID
-      expect((result as typeof BaseInsertPayloadSchema.inferOut).id).toMatch(
-        /^act_/
-      );
-    });
-
-    test('should generate default ID when not provided', () => {
-      const payload = {
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'auto-process',
-        },
-      };
-
-      const result = BaseInsertPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect((result as typeof BaseInsertPayloadSchema.inferOut).id).toMatch(
-        /^act_/
-      );
-    });
-  });
-
-  describe('BaseUpdatePayloadSchema', () => {
-    test('should accept update with performer', () => {
-      const payload = {
-        performedBy: {
-          type: 'automation' as const,
-          identifier: 'scheduled-task',
-        },
-        metadata: { updated: true },
-      };
-
-      const result = BaseUpdatePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should accept empty update payload', () => {
-      const payload = {};
-
-      const result = BaseUpdatePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should accept update with only metadata', () => {
-      const payload = {
-        metadata: { version: '2.0' },
-      };
-
-      const result = BaseUpdatePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-  });
-});

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

@@ -1,392 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { generateUserId } from '../../customer/schema.js';
-import {
-  ActivityPayloadSchema,
-  ActivitySchema,
-  type InsertActivityPayload,
-  InsertActivityPayloadSchema,
-  UpdateActivityPayloadSchema,
-} from './schema.js';
-import { generateActivityId } from './utils.js';
-
-describe('Activity Schema - Main', () => {
-  describe('ActivitySchema', () => {
-    test('should accept note activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'note' as const,
-        message: 'Test note message',
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        source: 'web-app',
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept authentication activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'authentication' as const,
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        message: 'string',
-        identity: generateUserId(),
-        status: 'success',
-        source: 'login-form',
-        isMutateable: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { method: 'email' },
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept authorization activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'authorization' as const,
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'auth-service',
-        },
-        message: 'string',
-        status: 'success',
-        source: 'rbac-check',
-        isMutateable: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { resource: 'users' },
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept operation activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'operation' as const,
-        performedBy: {
-          type: 'automation' as const,
-          identifier: 'data-sync',
-        },
-        message: 'string',
-        operation: 'delete',
-        target: generateUserId(),
-        source: 'cron-job',
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { operation: 'sync' },
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept unknown activity', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'unknown' as const,
-        performedBy: {
-          type: 'guest' as const,
-          identifier: 'anonymous',
-        },
-        message: 'string',
-        source: 'external-api',
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject invalid activity type', () => {
-      const activity = {
-        id: generateActivityId(),
-        type: 'invalid_type',
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'test',
-        },
-        source: 'test',
-        isMutateable: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = ActivitySchema(activity);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('ActivityPayloadSchema', () => {
-    test('should accept note activity payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'note' as const,
-        message: 'Test note',
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        source: 'web-app',
-        isMutateable: true,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: { urgent: true },
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should accept authentication activity payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'authentication' as const,
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        identity: generateUserId(),
-        message: 'string',
-        status: 'success',
-        source: 'mobile-app',
-        isMutateable: false,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: { device: 'iPhone' },
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept authorization activity payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'authorization' as const,
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'permission-service',
-        },
-        message: 'string',
-        status: 'success',
-        source: 'api-gateway',
-        isMutateable: false,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: { action: 'read' },
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept operation activity payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'operation' as const,
-        performedBy: {
-          type: 'automation' as const,
-          identifier: 'backup-service',
-        },
-        operation: 'create',
-        target: 'target-id',
-        message: 'string',
-        source: 'scheduler',
-        isMutateable: true,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: { backup_type: 'full' },
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept unknown activity payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'unknown' as const,
-        performedBy: {
-          type: 'integration' as const,
-          identifier: 'webhook-handler',
-        },
-        message: 'string',
-        source: 'external-webhook',
-        isMutateable: true,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: { webhook_id: 'wh_123' },
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject invalid activity type in payload', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'invalid_type',
-        performedBy: {
-          type: 'system' as const,
-          identifier: 'test',
-        },
-        source: 'test',
-        isMutateable: true,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        metadata: {},
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject payload with invalid date format', () => {
-      const payload = {
-        id: generateActivityId(),
-        type: 'note' as const,
-        message: 'Test note',
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        source: 'web-app',
-        isMutateable: true,
-        createdAt: 'invalid-date',
-        updatedAt: new Date().toISOString(),
-        metadata: {},
-      };
-
-      const result = ActivityPayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('InsertActivityPayloadSchema', () => {
-    test('should accept valid insert payload', () => {
-      const payload = {
-        type: 'note' as const,
-        message: 'New note',
-        performedBy: {
-          type: 'identity' as const,
-          identifier: 'user@example.com',
-        },
-        metadata: { priority: 'high' },
-      };
-
-      const result = InsertActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept minimal insert payload', () => {
-      const payload = {
-        type: 'note' as const,
-        message: 'Simple note',
-      };
-
-      const result = InsertActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      // Should generate ID automatically
-      expect((result as InsertActivityPayload).id).toMatch(/^act_/);
-    });
-
-    test('should reject insert payload missing required fields', () => {
-      const payload = {
-        type: 'note' as const,
-        // missing message
-      };
-
-      const result = InsertActivityPayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject insert payload with invalid type', () => {
-      const payload = {
-        type: 'invalid_type',
-        message: 'Test message',
-      };
-
-      const result = InsertActivityPayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('UpdateActivityPayloadSchema', () => {
-    test('should accept update payload with message', () => {
-      const payload = {
-        type: 'note' as const,
-        message: 'Updated message',
-        metadata: { updated: true },
-      };
-
-      const result = UpdateActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should accept update payload without message', () => {
-      const payload = {
-        type: 'note' as const,
-        performedBy: {
-          type: 'automation' as const,
-          identifier: 'update-service',
-        },
-        metadata: { auto_updated: true },
-      };
-
-      const result = UpdateActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept minimal update payload', () => {
-      const payload = {
-        type: 'note' as const,
-      };
-
-      const result = UpdateActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject update payload with invalid type', () => {
-      const payload = {
-        type: 'invalid_type',
-        message: 'Updated message',
-      };
-
-      const result = UpdateActivityPayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should accept update with only metadata', () => {
-      const payload = {
-        type: 'note' as const,
-        metadata: { version: '2.0' },
-      };
-
-      const result = UpdateActivityPayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-  });
-});