@go-mondo/identity-sdk 0.0.2-beta.9 → 0.0.2-beta.92

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":"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"}
+{"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,8 +1,8 @@
-import { type } from 'arktype';
+import * as z from 'zod/v4';
 import { AppIdSchema } from '../../app/schema.js';
-import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/index.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 { MetadataMapPropertySchema, MetadataRecordPropertySchema, UpsertMetadataPropertySchema, } from '../../common/schema/metadata.js';
 import { Model, generateActivityId } from './utils.js';
 export const ActivityType = {
     UNKNOWN: 'unknown',
@@ -19,37 +19,49 @@ export const PerformerType = {
     INTEGRATION: 'integration',
 };
 export const ActivityIdSchema = KSUIDSchema(Model.Activity.UIDPrefix);
-export const ActivityIdPropertySchema = type({
+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(),
 });
-const CommonSchema = type({
+const CommonSchema = z.object({
     id: ActivityIdSchema,
     performedBy: PerformedBySchema,
     source: SourceSchema,
     app: AppIdSchema.optional(),
-    isMutateable: type('boolean'),
+    isMutateable: z.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({
+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,
+    ...MetadataRecordPropertySchema.shape,
+});
+export const BaseInsertPayloadSchema = z.object({
     id: ActivityIdSchema.default(() => generateActivityId()),
     performedBy: PerformedBySchema.optional(),
-}).and(UpsertMetadataPropertyPayloadSchema);
-export const BaseUpdatePayloadSchema = type({
+    ...UpsertMetadataPropertySchema.shape,
+});
+export const BaseUpdatePayloadSchema = z.object({
     performedBy: PerformedBySchema.optional(),
-}).and(UpsertMetadataPropertyPayloadSchema);
+    ...UpsertMetadataPropertySchema.shape,
+});

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

@@ -1,4 +1,3 @@
-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';
@@ -25,40 +24,55 @@ describe('Activity Schema - Base', () => {
     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);
+            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', () => {
-            expect(ActivityIdSchema('invalid_id')).toBeInstanceOf(type.errors);
-            expect(ActivityIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+            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', () => {
-            expect(ActivityIdSchema(123)).toBeInstanceOf(type.errors);
-            expect(ActivityIdSchema(null)).toBeInstanceOf(type.errors);
+            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(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            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({});
-            expect(result).toBeInstanceOf(type.errors);
+            const result = ActivityIdPropertySchema.safeParse({});
+            expect(result.success).toBe(false);
         });
     });
     describe('SourceSchema', () => {
         test('should accept string source', () => {
-            const result = SourceSchema('api-request');
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBe('api-request');
+            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', () => {
-            expect(SourceSchema(123)).toBeInstanceOf(type.errors);
-            expect(SourceSchema(null)).toBeInstanceOf(type.errors);
+            const result1 = SourceSchema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = SourceSchema.safeParse(null);
+            expect(result2.success).toBe(false);
         });
     });
     describe('PerformedBySchema', () => {
@@ -67,18 +81,24 @@ describe('Activity Schema - Base', () => {
                 type: 'system',
                 identifier: 'system-process',
             };
-            const result = PerformedBySchema(performer);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(performer);
+            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(performer);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(performer);
+            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 = [
@@ -93,8 +113,9 @@ describe('Activity Schema - Base', () => {
                     type: performerType,
                     identifier: `test-${performerType}`,
                 };
-                const result = PerformedBySchema(performer);
-                expect(result).not.toBeInstanceOf(type.errors);
+                const result = PerformedBySchema.safeParse(performer);
+                // Parse succeeds for valid data
+                expect(result.success).toBe(true);
             }
         });
         test('should reject invalid performer type', () => {
@@ -102,12 +123,12 @@ describe('Activity Schema - Base', () => {
                 type: 'invalid',
                 identifier: 'test',
             };
-            const result = PerformedBySchema(performer);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = PerformedBySchema.safeParse(performer);
+            expect(result.success).toBe(false);
         });
         test('should reject missing fields', () => {
-            expect(PerformedBySchema({ type: 'system' })).toBeInstanceOf(type.errors);
-            expect(PerformedBySchema({ identifier: 'test' })).toBeInstanceOf(type.errors);
+            const result = PerformedBySchema.safeParse({ identifier: 'test' });
+            expect(result.success).toBe(false);
         });
     });
     describe('BaseSchema', () => {
@@ -125,8 +146,8 @@ describe('Activity Schema - Base', () => {
                 updatedAt: new Date(),
                 metadata: { key: 'value' },
             };
-            const result = BaseSchema(activity);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = BaseSchema.safeParse(activity);
+            // Parse succeeds for valid data
         });
         test('should accept activity without app', () => {
             const activity = {
@@ -141,8 +162,8 @@ describe('Activity Schema - Base', () => {
                 updatedAt: new Date(),
                 metadata: {},
             };
-            const result = BaseSchema(activity);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = BaseSchema.safeParse(activity);
+            // Parse succeeds for valid data
         });
         test('should accept activity with optional dates', () => {
             const activity = {
@@ -159,8 +180,8 @@ describe('Activity Schema - Base', () => {
                 deactivatedAt: new Date(),
                 metadata: {},
             };
-            const result = BaseSchema(activity);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = BaseSchema.safeParse(activity);
+            // Parse succeeds for valid data
         });
         test('should reject missing required fields', () => {
             const activity = {
@@ -171,8 +192,8 @@ describe('Activity Schema - Base', () => {
                 },
                 // missing source, isMutateable, dates, metadata
             };
-            const result = BaseSchema(activity);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = BaseSchema.safeParse(activity);
+            expect(result.success).toBe(false);
         });
     });
     describe('BaseInsertPayloadSchema', () => {
@@ -185,15 +206,18 @@ describe('Activity Schema - Base', () => {
                 },
                 metadata: { source: 'api' },
             };
-            const result = BaseInsertPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = BaseInsertPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
         });
         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_/);
+            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 = {
@@ -202,9 +226,12 @@ describe('Activity Schema - Base', () => {
                     identifier: 'auto-process',
                 },
             };
-            const result = BaseInsertPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result.id).toMatch(/^act_/);
+            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', () => {
@@ -216,22 +243,25 @@ describe('Activity Schema - Base', () => {
                 },
                 metadata: { updated: true },
             };
-            const result = BaseUpdatePayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            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(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(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(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = BaseUpdatePayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
         });
     });
 });