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

package/dist/esm/activity/resources.test.js

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { ActivityResources } from './resources.js';
+describe('Activity Resources', () => {
+    let mockInstance;
+    let activityResources;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock MondoIdentity instance
+        mockInstance = {
+            config: {
+                host: 'https://api.example.com',
+                accessToken: 'test-token',
+            },
+            authorizer: vi.fn((req) => req),
+        };
+        activityResources = new ActivityResources(mockInstance);
+    });
+    describe('ActivityResources class', () => {
+        test('should initialize with MondoIdentity instance', () => {
+            expect(activityResources).toBeInstanceOf(ActivityResources);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(activityResources['instance']).toBe(mockInstance);
+        });
+        describe('buildPath static method', () => {
+            test('should build path with source', () => {
+                const path = ActivityResources.buildPath('app_123');
+                expect(path).toBe('/v1/activities/app_123');
+            });
+            test('should return existing path if source already starts with /v1/activities', () => {
+                const existingPath = '/v1/activities/app_456/custom/path';
+                const path = ActivityResources.buildPath(existingPath);
+                expect(path).toBe(existingPath);
+            });
+            test('should handle empty source', () => {
+                const path = ActivityResources.buildPath('');
+                expect(path).toBe('/v1/activities');
+            });
+            test('should filter out falsy values correctly', () => {
+                const path = ActivityResources.buildPath('user_789');
+                expect(path).toBe('/v1/activities/user_789');
+            });
+            test('should handle complex source paths', () => {
+                const path = ActivityResources.buildPath('organization_123');
+                expect(path).toBe('/v1/activities/organization_123');
+            });
+            test('should handle various source ID patterns', () => {
+                const testCases = [
+                    { input: 'app_12345', expected: '/v1/activities/app_12345' },
+                    { input: 'user_67890', expected: '/v1/activities/user_67890' },
+                    { input: 'org_abcdef', expected: '/v1/activities/org_abcdef' },
+                    {
+                        input: '/v1/activities/existing',
+                        expected: '/v1/activities/existing',
+                    },
+                    {
+                        input: '/v1/activities/nested/path',
+                        expected: '/v1/activities/nested/path',
+                    },
+                ];
+                for (const { input, expected } of testCases) {
+                    expect(ActivityResources.buildPath(input)).toBe(expected);
+                }
+            });
+            test('should handle special characters in source', () => {
+                const path = ActivityResources.buildPath('app-123_test.source');
+                expect(path).toBe('/v1/activities/app-123_test.source');
+            });
+            test('should maintain path structure integrity', () => {
+                const basePath = '/v1/activities';
+                const source = 'test_source';
+                const expectedPath = `${basePath}/${source}`;
+                expect(ActivityResources.buildPath(source)).toBe(expectedPath);
+            });
+        });
+        describe('listItems method delegation', () => {
+            test('should have listItems method that accepts source parameter', () => {
+                expect(typeof activityResources.listItems).toBe('function');
+                expect(activityResources.listItems.length).toBeGreaterThanOrEqual(1);
+            });
+            test('should have listItems method that accepts optional pagination parameter', () => {
+                expect(activityResources.listItems.length).toBe(2);
+            });
+        });
+    });
+    describe('PATH constant', () => {
+        test('should export correct PATH constant', async () => {
+            const { PATH } = await import('./resources.js');
+            expect(PATH).toBe('/v1/activities');
+        });
+    });
+    describe('URL building scenarios', () => {
+        test('should create proper URL structure for different source types', () => {
+            const scenarios = [
+                { source: 'app_production', expected: '/v1/activities/app_production' },
+                {
+                    source: 'user_session_123',
+                    expected: '/v1/activities/user_session_123',
+                },
+                {
+                    source: 'organization_enterprise',
+                    expected: '/v1/activities/organization_enterprise',
+                },
+                {
+                    source: 'workflow_automation',
+                    expected: '/v1/activities/workflow_automation',
+                },
+            ];
+            for (const { source, expected } of scenarios) {
+                const result = ActivityResources.buildPath(source);
+                expect(result).toBe(expected);
+                expect(result).toMatch(/^\/v1\/activities\//);
+            }
+        });
+        test('should handle edge cases in path building', () => {
+            // Test with already formatted paths
+            expect(ActivityResources.buildPath('/v1/activities/already/formatted')).toBe('/v1/activities/already/formatted');
+            // Test with empty string
+            expect(ActivityResources.buildPath('')).toBe('/v1/activities');
+            // Test with single character
+            expect(ActivityResources.buildPath('a')).toBe('/v1/activities/a');
+            // Test with numbers only
+            expect(ActivityResources.buildPath('123')).toBe('/v1/activities/123');
+        });
+        test('should create valid URL paths for various content types', () => {
+            const contentTypes = [
+                'authentication_events',
+                'user_management_logs',
+                'system_diagnostics',
+                'audit_trail_data',
+                'security_incidents',
+            ];
+            for (const contentType of contentTypes) {
+                const path = ActivityResources.buildPath(contentType);
+                expect(path).toBe(`/v1/activities/${contentType}`);
+                expect(path).toMatch(/^\/v1\/activities\/[a-z_]+$/);
+            }
+        });
+    });
+    describe('Integration with MondoIdentity instance', () => {
+        test('should store MondoIdentity instance internally', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = activityResources['instance'];
+            expect(internalInstance).toBe(mockInstance);
+            expect(internalInstance.config.host).toBe('https://api.example.com');
+            expect(internalInstance.config.accessToken).toBe('test-token');
+        });
+        test('should maintain reference to authorizer function', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = activityResources['instance'];
+            expect(typeof internalInstance.authorizer).toBe('function');
+            expect(internalInstance.authorizer).toBe(mockInstance.authorizer);
+        });
+        test('should work with different MondoIdentity configurations', () => {
+            const customInstance = {
+                config: {
+                    host: 'https://custom.api.com',
+                    accessToken: 'custom-token',
+                },
+                authorizer: vi.fn(),
+            };
+            const customResources = new ActivityResources(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance']).toBe(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance'].config.host).toBe('https://custom.api.com');
+        });
+    });
+    describe('Class inheritance and structure', () => {
+        test('should have proper class structure', () => {
+            expect(ActivityResources).toBeDefined();
+            expect(typeof ActivityResources).toBe('function');
+            expect(ActivityResources.prototype.constructor).toBe(ActivityResources);
+        });
+        test('should have static buildPath method', () => {
+            expect(typeof ActivityResources.buildPath).toBe('function');
+            expect(ActivityResources.buildPath).toBeDefined();
+        });
+        test('should have instance methods', () => {
+            expect(typeof activityResources.listItems).toBe('function');
+            expect(activityResources.listItems).toBeDefined();
+        });
+        test('should maintain method binding', () => {
+            const { listItems } = activityResources;
+            expect(typeof listItems).toBe('function');
+            // Method should be bound to instance
+            expect(listItems.length).toBe(2); // source + optional pagination
+        });
+    });
+});

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

@@ -0,0 +1,86 @@
+export declare const ActivityType: {
+    readonly UNKNOWN: "unknown";
+    readonly NOTE: "note";
+    readonly OPERATION: "operation";
+    readonly AUTHORIZATION: "authorization";
+    readonly AUTHENTICATION: "authentication";
+};
+export type AnyActivityType = (typeof ActivityType)[keyof typeof ActivityType];
+export declare const PerformerType: {
+    readonly SYSTEM: "system";
+    readonly GUEST: "guest";
+    readonly IDENTITY: "identity";
+    readonly AUTOMATION: "automation";
+    readonly INTEGRATION: "integration";
+};
+export type AnyPerformerType = (typeof PerformerType)[keyof typeof PerformerType];
+export declare const ActivityIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type ActivityId = typeof ActivityIdSchema.inferOut;
+export declare const ActivityIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type ActivityIdProperty = typeof ActivityIdPropertySchema.inferOut;
+export declare const SourceSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export declare const PerformedBySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "system" | "guest" | "identity" | "automation" | "integration";
+    identifier: string;
+}, {}>;
+export type PerformedBy = typeof PerformedBySchema.inferOut;
+export declare const BaseSchema: 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>>;
+}, {}>;
+export declare const BasePayloadSchema: 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;
+}, {}>;
+export declare const BaseInsertPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+    performedBy?: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    } | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export declare const BaseUpdatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    performedBy?: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    } | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+//# sourceMappingURL=base.d.ts.map

package/dist/esm/activity/schema/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/base.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,gBAAgB,qEAAwC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,wBAAwB;;MAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC;AAE1E,eAAO,MAAM,YAAY,qEAAiB,CAAC;AAE3C,eAAO,MAAM,iBAAiB;;;MAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAU5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;MAKU,CAAC;AAElC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;MAKO,CAAC;AAEtC,eAAO,MAAM,uBAAuB;;;;;;;;;;;MAGO,CAAC;AAE5C,eAAO,MAAM,uBAAuB;;;;;;;;;;MAEO,CAAC"}

package/dist/esm/activity/schema/base.js

@@ -0,0 +1,55 @@
+import { type } from 'arktype';
+import { AppIdSchema } from '../../app/schema.js';
+import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/index.js';
+import { KSUIDSchema } from '../../common/schema/id.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+import { Model, generateActivityId } from './utils.js';
+export const ActivityType = {
+    UNKNOWN: 'unknown',
+    NOTE: 'note',
+    OPERATION: 'operation',
+    AUTHORIZATION: 'authorization',
+    AUTHENTICATION: 'authentication',
+};
+export const PerformerType = {
+    SYSTEM: 'system',
+    GUEST: 'guest',
+    IDENTITY: 'identity',
+    AUTOMATION: 'automation',
+    INTEGRATION: 'integration',
+};
+export const ActivityIdSchema = KSUIDSchema(Model.Activity.UIDPrefix);
+export const ActivityIdPropertySchema = type({
+    id: ActivityIdSchema,
+});
+export const SourceSchema = type('string');
+export const PerformedBySchema = type({
+    type: type.enumerated(PerformerType.SYSTEM, PerformerType.GUEST, PerformerType.IDENTITY, PerformerType.AUTOMATION, PerformerType.INTEGRATION),
+    identifier: type('string'),
+});
+const CommonSchema = type({
+    id: ActivityIdSchema,
+    performedBy: PerformedBySchema,
+    source: SourceSchema,
+    app: AppIdSchema.optional(),
+    isMutateable: type('boolean'),
+});
+export const BaseSchema = CommonSchema.and({
+    createdAt: RequiredDateSchema,
+    updatedAt: RequiredDateSchema,
+    deletedAt: OptionalDateSchema.optional(),
+    deactivatedAt: OptionalDateSchema.optional(),
+}).and(MetadataMapPropertySchema);
+export const BasePayloadSchema = CommonSchema.and({
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const BaseInsertPayloadSchema = type({
+    id: ActivityIdSchema.default(() => generateActivityId()),
+    performedBy: PerformedBySchema.optional(),
+}).and(UpsertMetadataPropertyPayloadSchema);
+export const BaseUpdatePayloadSchema = type({
+    performedBy: PerformedBySchema.optional(),
+}).and(UpsertMetadataPropertyPayloadSchema);

package/dist/esm/activity/schema/base.test.d.ts

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

package/dist/esm/activity/schema/base.test.d.ts.map

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

package/dist/esm/activity/schema/base.test.js

@@ -0,0 +1,237 @@
+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',
+                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',
+                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',
+            ];
+            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',
+                    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',
+                    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',
+                    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',
+                    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',
+                    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.id).toMatch(/^act_/);
+        });
+        test('should generate default ID when not provided', () => {
+            const payload = {
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auto-process',
+                },
+            };
+            const result = BaseInsertPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.id).toMatch(/^act_/);
+        });
+    });
+    describe('BaseUpdatePayloadSchema', () => {
+        test('should accept update with performer', () => {
+            const payload = {
+                performedBy: {
+                    type: 'automation',
+                    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);
+        });
+    });
+});