@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

package/dist/esm/activity/schema/types/operation.test.js

@@ -0,0 +1,342 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { OperationType, OperationActivitySchema, OperationActivityPayloadSchema, } from './operation.js';
+import { generateActivityId } from '../utils.js';
+describe('Activity Schema - Operation', () => {
+    describe('OperationType', () => {
+        test('should contain expected operation values', () => {
+            expect(OperationType.CREATE).toBe('create');
+            expect(OperationType.UPDATE).toBe('update');
+            expect(OperationType.DELETE).toBe('delete');
+            expect(OperationType.AUTOMATION).toBe('automation');
+        });
+    });
+    describe('OperationActivitySchema', () => {
+        test('should accept complete operation activity with create', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                message: 'User account created successfully',
+                target: 'user:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'admin@example.com',
+                },
+                source: 'admin-panel',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { entity: 'user', action: 'create' },
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity with update', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'update',
+                message: 'User profile updated',
+                target: 'profile:456',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'user-dashboard',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { fields_updated: ['name', 'email'] },
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity with delete', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'delete',
+                message: 'Resource deleted permanently',
+                target: 'resource:789',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'cleanup-service',
+                },
+                source: 'garbage-collector',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { cascade: true, reason: 'retention_policy' },
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity with automation', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'automation',
+                message: 'Automated backup completed',
+                target: 'database:primary',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'backup-cron',
+                },
+                source: 'scheduler',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { backup_size: '2.5GB', duration: '45min' },
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity with optional fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                message: 'New workspace created',
+                target: 'workspace:new-team',
+                performedBy: {
+                    type: 'integration',
+                    identifier: 'provisioning-api',
+                },
+                source: 'external-system',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: { template: 'standard', auto_provision: true },
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject operation activity with wrong type', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                operation: 'create',
+                message: 'Wrong type',
+                target: 'test:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject operation activity with invalid operation', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'invalid_operation',
+                message: 'Test message',
+                target: 'test:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject operation activity missing required fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                // missing message, target
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = OperationActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('OperationActivityPayloadSchema', () => {
+        test('should accept complete operation payload with create', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                message: 'New entity created',
+                target: 'entity:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'creator@example.com',
+                },
+                source: 'web-interface',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { entity_type: 'project', owner: 'team-alpha' },
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept operation payload with update', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'update',
+                message: 'Configuration updated',
+                target: 'config:app-settings',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'config-sync',
+                },
+                source: 'config-service',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { version: '2.1.0', changes: 3 },
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation payload with delete', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'delete',
+                message: 'Expired token removed',
+                target: 'token:abc123',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'token-cleanup',
+                },
+                source: 'maintenance-job',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { expired_at: '2024-01-01T00:00:00Z' },
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation payload with automation', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'automation',
+                message: 'Data synchronization completed',
+                target: 'sync:daily-reports',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'data-sync-service',
+                },
+                source: 'scheduled-task',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { records_synced: 1500, status: 'success' },
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept payload with optional date fields', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                message: 'Temporary resource created',
+                target: 'temp:resource-456',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous-session',
+                },
+                source: 'demo-environment',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: { temporary: true, ttl: 3600 },
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with invalid date format', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'create',
+                message: 'Test operation',
+                target: 'test:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: 'invalid-date-format',
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with wrong type', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'authorization',
+                operation: 'create',
+                message: 'Wrong type',
+                target: 'test:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with invalid operation', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                operation: 'invalid_op',
+                message: 'Invalid operation',
+                target: 'test:123',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'api',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = OperationActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/activity/schema/types/unknown.d.ts

@@ -0,0 +1,42 @@
+export declare const UnknownActivitySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "unknown";
+    message: string;
+}, {}>;
+export type UnknownActivityProperties = typeof UnknownActivitySchema.inferIn;
+export type UnknownActivity = typeof UnknownActivitySchema.inferOut;
+export declare const UnknownActivityPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "unknown";
+    message: string;
+}, {}>;
+export type UnknownActivityPayload = typeof UnknownActivityPayloadSchema.inferOut;
+//# sourceMappingURL=unknown.d.ts.map

package/dist/esm/activity/schema/types/unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/unknown.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;MAAoC,CAAC;AACvE,MAAM,MAAM,yBAAyB,GAAG,OAAO,qBAAqB,CAAC,OAAO,CAAC;AAC7E,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;MACC,CAAC;AAC3C,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC"}

package/dist/esm/activity/schema/types/unknown.js

@@ -0,0 +1,8 @@
+import { type } from 'arktype';
+import { BasePayloadSchema, BaseSchema } from '../base.js';
+const BaseUnknownSchema = type({
+    type: type("'unknown'"),
+    message: type('string'),
+});
+export const UnknownActivitySchema = BaseSchema.and(BaseUnknownSchema);
+export const UnknownActivityPayloadSchema = BasePayloadSchema.and(BaseUnknownSchema);

package/dist/esm/activity/schema/types/unknown.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unknown.test.d.ts.map

package/dist/esm/activity/schema/types/unknown.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.test.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/unknown.test.ts"],"names":[],"mappings":""}

package/dist/esm/activity/schema/types/unknown.test.js

@@ -0,0 +1,273 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateActivityId } from '../utils.js';
+import { UnknownActivityPayloadSchema, UnknownActivitySchema, } from './unknown.js';
+describe('Activity Schema - Unknown', () => {
+    describe('UnknownActivitySchema', () => {
+        test('should accept complete unknown activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Unrecognized activity detected',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous-user',
+                },
+                source: 'external-webhook',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { webhook_source: 'third-party', event_type: 'custom' },
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept unknown activity with system performer', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'System detected unexpected behavior',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'anomaly-detector',
+                },
+                source: 'monitoring-service',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { severity: 'low', category: 'anomaly' },
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept unknown activity with integration performer', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Received unknown event from integration',
+                performedBy: {
+                    type: 'integration',
+                    identifier: 'webhook-handler',
+                },
+                source: 'api-gateway',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {
+                    integration: 'external-crm',
+                    event: 'unknown_event_type',
+                    raw_data: '{"type":"unknown","data":{}}',
+                },
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept unknown activity with optional fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Legacy system activity logged',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'legacy-bridge',
+                },
+                source: 'legacy-system',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {
+                    legacy_id: 'old_system_123',
+                    migrated: false,
+                },
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject unknown activity with wrong type', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Wrong type activity',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject unknown activity missing message', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                // missing message
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject unknown activity with non-string message', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 123,
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject unknown activity missing required base fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Test message',
+                // missing performedBy, source, isMutateable, dates, metadata
+            };
+            const result = UnknownActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UnknownActivityPayloadSchema', () => {
+        test('should accept complete unknown activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Unknown event from external source',
+                performedBy: {
+                    type: 'integration',
+                    identifier: 'webhook-processor',
+                },
+                source: 'external-api',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {
+                    source_system: 'partner-api',
+                    event_id: 'evt_123456',
+                    processed: false,
+                },
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal unknown activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Simple unknown event',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'unknown-source',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept payload with optional date fields', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Archived unknown activity',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'archival-service',
+                },
+                source: 'data-cleanup',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {
+                    archived: true,
+                    retention_policy: 'long_term',
+                },
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with invalid date format', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                message: 'Test unknown activity',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: 'invalid-date-format',
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with wrong type', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                message: 'Wrong type payload',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload missing message', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                // missing message
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UnknownActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/activity/schema/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const Model: {
+    readonly Activity: {
+        readonly UIDPrefix: "act";
+    };
+};
+export declare function generateActivityId(): string;
+//# sourceMappingURL=utils.d.ts.map