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

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

@@ -0,0 +1,317 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateActivityId } from '../utils.js';
+import { InsertNoteActivityPayloadSchema, NoteActivityPayloadSchema, NoteActivitySchema, UpdateNoteActivityPayloadSchema, } from './note.js';
+describe('Activity Schema - Note', () => {
+    describe('NoteActivitySchema', () => {
+        test('should accept complete note activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'This is a test note',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { priority: 'high' },
+            };
+            const result = NoteActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept note activity with optional fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Note with optional fields',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'automated-process',
+                },
+                source: 'background-job',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: { category: 'system' },
+            };
+            const result = NoteActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject note activity with wrong type', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                message: 'This should fail',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = NoteActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject note activity missing message', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                // missing message
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = NoteActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject note activity with non-string message', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 123,
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = NoteActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('NoteActivityPayloadSchema', () => {
+        test('should accept complete note activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Test note payload',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'mobile-app',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { urgent: true },
+            };
+            const result = NoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal note activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Simple note',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auto-note',
+                },
+                source: 'scheduler',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = NoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept payload with optional date fields', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Note with dates',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'public-form',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: { public: true },
+            };
+            const result = NoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with invalid date format', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Test note',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: 'invalid-date-format',
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = NoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with wrong type', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'authentication',
+                message: 'Wrong type',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = NoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertNoteActivityPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'New note to insert',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                metadata: { source: 'manual' },
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {
+                type: 'note',
+                message: 'Basic note',
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Should generate ID automatically
+            expect(result.id).toMatch(/^act_/);
+        });
+        test('should accept insert payload without performer', () => {
+            const payload = {
+                type: 'note',
+                message: 'Auto-generated note',
+                metadata: { automated: true },
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject insert payload missing type', () => {
+            const payload = {
+                message: 'Note without type',
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject insert payload missing message', () => {
+            const payload = {
+                type: 'note',
+                // missing message
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject insert payload with wrong type', () => {
+            const payload = {
+                type: 'operation',
+                message: 'Wrong type note',
+            };
+            const result = InsertNoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateNoteActivityPayloadSchema', () => {
+        test('should accept update payload with message', () => {
+            const payload = {
+                type: 'note',
+                message: 'Updated note message',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                metadata: { updated: true },
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept update payload without message', () => {
+            const payload = {
+                type: 'note',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'note-updater',
+                },
+                metadata: { last_modified: new Date().toISOString() },
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal update payload', () => {
+            const payload = {
+                type: 'note',
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept update with only metadata', () => {
+            const payload = {
+                type: 'note',
+                metadata: { priority: 'low' },
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject update payload with wrong type', () => {
+            const payload = {
+                type: 'unknown',
+                message: 'Updated message',
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject update payload with invalid performer', () => {
+            const payload = {
+                type: 'note',
+                message: 'Updated note',
+                performedBy: {
+                    type: 'invalid_performer_type',
+                    identifier: 'test',
+                },
+            };
+            const result = UpdateNoteActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,53 @@
+export declare const OperationType: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+    readonly AUTOMATION: "automation";
+};
+export type AnyOperationType = (typeof OperationType)[keyof typeof OperationType];
+export declare const OperationActivitySchema: 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: "operation";
+    operation: "delete" | "automation" | "create" | "update";
+    message: string;
+    target: string;
+}, {}>;
+export type OperationActivityProperties = typeof OperationActivitySchema.inferIn;
+export type OperationActivity = typeof OperationActivitySchema.inferOut;
+export declare const OperationActivityPayloadSchema: 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: "operation";
+    operation: "delete" | "automation" | "create" | "update";
+    message: string;
+    target: string;
+}, {}>;
+export type OperationActivityPayload = typeof OperationActivityPayloadSchema.inferOut;
+//# sourceMappingURL=operation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/operation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAgBrD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;MAAsC,CAAC;AAC3E,MAAM,MAAM,2BAA2B,GACrC,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACzC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;MACC,CAAC;AAC7C,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+import { BasePayloadSchema, BaseSchema } from '../base.js';
+export const OperationType = {
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    AUTOMATION: 'automation',
+};
+const OperationSchema = type.enumerated(OperationType.CREATE, OperationType.UPDATE, OperationType.DELETE, OperationType.AUTOMATION);
+const BaseOperationSchema = type({
+    type: type("'operation'"),
+    operation: OperationSchema,
+    message: type('string'),
+    target: type('string'),
+});
+export const OperationActivitySchema = BaseSchema.and(BaseOperationSchema);
+export const OperationActivityPayloadSchema = BasePayloadSchema.and(BaseOperationSchema);

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

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

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

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