@go-mondo/identity-sdk 0.0.2-beta.4 → 0.0.2-beta.41

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

@@ -1,54 +1,105 @@
-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 BasePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    performedBy: {
-        type: "system" | "guest" | "identity" | "automation" | "integration";
-        identifier: string;
-    };
-    source: string;
-    isMutateable: boolean;
-    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").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/internal/attributes.ts").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/internal/attributes.ts").Out<{
-        [x: string]: string | number | boolean;
-    } | null>) | undefined;
-}, {}>;
+import * as z from 'zod/v4';
+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: z.ZodString;
+export type ActivityId = z.output<typeof ActivityIdSchema>;
+export declare const ActivityIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ActivityIdProperty = z.output<typeof ActivityIdPropertySchema>;
+export declare const SourceSchema: z.ZodString;
+export declare const PerformedBySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        system: "system";
+        guest: "guest";
+        identity: "identity";
+        automation: "automation";
+        integration: "integration";
+    }>;
+    identifier: z.ZodString;
+}, z.core.$strip>;
+export type PerformedBy = z.output<typeof PerformedBySchema>;
+export declare const BaseSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    deactivatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    deletedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    id: z.ZodString;
+    performedBy: z.ZodObject<{
+        type: z.ZodEnum<{
+            system: "system";
+            guest: "guest";
+            identity: "identity";
+            automation: "automation";
+            integration: "integration";
+        }>;
+        identifier: z.ZodString;
+    }, z.core.$strip>;
+    source: z.ZodString;
+    app: z.ZodOptional<z.ZodString>;
+    isMutateable: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const BasePayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+    performedBy: z.ZodObject<{
+        type: z.ZodEnum<{
+            system: "system";
+            guest: "guest";
+            identity: "identity";
+            automation: "automation";
+            integration: "integration";
+        }>;
+        identifier: z.ZodString;
+    }, z.core.$strip>;
+    source: z.ZodString;
+    app: z.ZodOptional<z.ZodString>;
+    isMutateable: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const BaseInsertPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    id: z.ZodDefault<z.ZodString>;
+    performedBy: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            system: "system";
+            guest: "guest";
+            identity: "identity";
+            automation: "automation";
+            integration: "integration";
+        }>;
+        identifier: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const BaseUpdatePayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    performedBy: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            system: "system";
+            guest: "guest";
+            identity: "identity";
+            automation: "automation";
+            integration: "integration";
+        }>;
+        identifier: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 //# sourceMappingURL=base.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/base.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,gBAAgB,qEAAc,CAAC;AAC5C,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;AAE5D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;MASO,CAAC;AAEtC,eAAO,MAAM,uBAAuB;;;;;;;;;;;MAGO,CAAC;AAE5C,eAAO,MAAM,uBAAuB;;;;;;;;;;MAEO,CAAC"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAoB5B,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,aAAwC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E,eAAO,MAAM,YAAY,aAAa,CAAC;AAEvC,eAAO,MAAM,iBAAiB;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAU7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAGlC,CAAC"}

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

@@ -1,31 +1,67 @@
-import { type } from 'arktype';
-import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
-import { MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-import { PerformerType } from './schema.js';
-import { generateActivityId } from './utils.js';
-export const ActivityIdSchema = type.string;
-export const ActivityIdPropertySchema = type({
+import * as z from 'zod/v4';
+import { AppIdSchema } from '../../app/schema.js';
+import { CreatedAtPropertyPayloadSchema, CreatedAtPropertySchema, DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, UpdatedAtPropertyPayloadSchema, UpdatedAtPropertySchema, } from '../../common/schema/dates.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 = z.object({
     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'),
+export const SourceSchema = z.string();
+export const PerformedBySchema = z.object({
+    type: z.enum([
+        PerformerType.SYSTEM,
+        PerformerType.GUEST,
+        PerformerType.IDENTITY,
+        PerformerType.AUTOMATION,
+        PerformerType.INTEGRATION,
+    ]),
+    identifier: z.string(),
 });
-export const BasePayloadSchema = type({
+const CommonSchema = z.object({
     id: ActivityIdSchema,
     performedBy: PerformedBySchema,
     source: SourceSchema,
-    isMutateable: type('boolean'),
-    createdAt: RequiredDatePayloadSchema,
-    updatedAt: RequiredDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(MetadataPayloadPropertySchema);
-export const BaseInsertPayloadSchema = type({
+    app: AppIdSchema.optional(),
+    isMutateable: z.boolean(),
+});
+export const BaseSchema = z.object({
+    ...CommonSchema.shape,
+    ...CreatedAtPropertySchema.shape,
+    ...UpdatedAtPropertySchema.shape,
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+export const BasePayloadSchema = z.object({
+    ...CommonSchema.shape,
+    ...CreatedAtPropertyPayloadSchema.shape,
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const BaseInsertPayloadSchema = z.object({
     id: ActivityIdSchema.default(() => generateActivityId()),
     performedBy: PerformedBySchema.optional(),
-}).and(UpsertMetadataPayloadPropertySchema);
-export const BaseUpdatePayloadSchema = type({
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});
+export const BaseUpdatePayloadSchema = z.object({
     performedBy: PerformedBySchema.optional(),
-}).and(UpsertMetadataPayloadPropertySchema);
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});

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,267 @@
+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.safeParse(id);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(id);
+            }
+        });
+        test('should reject invalid activity ID format', () => {
+            const result1 = ActivityIdSchema.safeParse('invalid_id');
+            expect(result1.success).toBe(false);
+            const result2 = ActivityIdSchema.safeParse('act_');
+            expect(result2.success).toBe(false);
+        });
+        test('should reject non-string values', () => {
+            const result1 = ActivityIdSchema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = ActivityIdSchema.safeParse(null);
+            expect(result2.success).toBe(false);
+        });
+    });
+    describe('ActivityIdPropertySchema', () => {
+        test('should accept valid id property', () => {
+            const payload = { id: generateActivityId() };
+            const result = ActivityIdPropertySchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
+        });
+        test('should reject missing id', () => {
+            const result = ActivityIdPropertySchema.safeParse({});
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('SourceSchema', () => {
+        test('should accept string source', () => {
+            const result = SourceSchema.safeParse('api-request');
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe('api-request');
+            }
+        });
+        test('should reject non-string values', () => {
+            const result1 = SourceSchema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = SourceSchema.safeParse(null);
+            expect(result2.success).toBe(false);
+        });
+    });
+    describe('PerformedBySchema', () => {
+        test('should accept valid performer with system type', () => {
+            const performer = {
+                type: 'system',
+                identifier: 'system-process',
+            };
+            const result = PerformedBySchema.safeParse(performer);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(performer);
+            }
+        });
+        test('should accept valid performer with identity type', () => {
+            const performer = {
+                type: 'identity',
+                identifier: 'user@example.com',
+            };
+            const result = PerformedBySchema.safeParse(performer);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).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.safeParse(performer);
+                // Parse succeeds for valid data
+                expect(result.success).toBe(true);
+            }
+        });
+        test('should reject invalid performer type', () => {
+            const performer = {
+                type: 'invalid',
+                identifier: 'test',
+            };
+            const result = PerformedBySchema.safeParse(performer);
+            expect(result.success).toBe(false);
+        });
+        test('should reject missing fields', () => {
+            const result = PerformedBySchema.safeParse({ identifier: 'test' });
+            expect(result.success).toBe(false);
+        });
+    });
+    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.safeParse(activity);
+            // Parse succeeds for valid data
+        });
+        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.safeParse(activity);
+            // Parse succeeds for valid data
+        });
+        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.safeParse(activity);
+            // Parse succeeds for valid data
+        });
+        test('should reject missing required fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'system',
+                    identifier: 'test',
+                },
+                // missing source, isMutateable, dates, metadata
+            };
+            const result = BaseSchema.safeParse(activity);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('BaseInsertPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user123',
+                },
+                metadata: { source: 'api' },
+            };
+            const result = BaseInsertPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {};
+            const result = BaseInsertPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                // Should generate default ID
+                expect(result.data.id).toMatch(/^act_/);
+            }
+        });
+        test('should generate default ID when not provided', () => {
+            const payload = {
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auto-process',
+                },
+            };
+            const result = BaseInsertPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.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.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(expect.objectContaining(payload));
+            }
+        });
+        test('should accept empty update payload', () => {
+            const payload = {};
+            const result = BaseUpdatePayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+        });
+        test('should accept update with only metadata', () => {
+            const payload = {
+                metadata: { version: '2.0' },
+            };
+            const result = BaseUpdatePayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+    });
+});