@go-mondo/identity-sdk 0.0.2-beta.7 → 0.0.2-beta.71

package/dist/esm/workspace/user/preferences/schema.js

@@ -1,16 +1,28 @@
-import { type } from 'arktype';
-import { OptionalDatePayloadSchema } from '../../../common/schema/dates.js';
-import { UpsertMetadataPayloadPropertySchema } from '../../../common/schema/metadata.js';
-const TableSchema = type({
-    columns: type('string').array().optional(),
+import * as z from 'zod/v4';
+import { DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, OptionalDatePayloadSchema, OptionalDateSchema, } from '../../../common/schema/dates.js';
+import { MetadataMapPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../../common/schema/metadata.js';
+const TableSchema = z.object({
+    columns: z.array(z.string()).optional(),
 });
-const TablesSchema = type.Record('string', TableSchema);
-const BaseAttributes = type({
+const TablesSchema = z.record(z.string(), TableSchema);
+const BaseSchema = z.object({
     views: TablesSchema.optional(),
 });
-export const UserPreferencesPayloadSchema = BaseAttributes.and({
-    'updatedAt?': OptionalDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(UpsertMetadataPayloadPropertySchema);
-export const UpsertUserPreferencesPayloadSchema = BaseAttributes.and(UpsertMetadataPayloadPropertySchema);
+export const UserPreferencesSchema = z.object({
+    ...BaseSchema.shape,
+    updatedAt: OptionalDateSchema,
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+export const UserPreferencesPayloadSchema = z.object({
+    ...BaseSchema.shape,
+    updatedAt: OptionalDatePayloadSchema,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});
+export const UpsertUserPreferencesPayloadSchema = z.object({
+    ...BaseSchema.shape,
+    ...UpsertMetadataPropertyPayloadSchema.shape,
+});

package/dist/esm/workspace/utils.d.ts

@@ -1,7 +1,4 @@
 export declare const Model: {
-    readonly Action: {
-        readonly UIDPrefix: "act";
-    };
     readonly Notification: {
         readonly UIDPrefix: "ntf";
     };

package/dist/esm/workspace/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/workspace/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;;;;;;;;CAUR,CAAC;AAEX,wBAAgB,gBAAgB,WAE/B;AAED,wBAAgB,cAAc,WAE7B;AAED,wBAAgB,sBAAsB,WAErC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/workspace/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,wBAAgB,gBAAgB,WAE/B;AAED,wBAAgB,cAAc,WAE7B;AAED,wBAAgB,sBAAsB,WAErC"}

package/dist/esm/workspace/utils.js

@@ -1,9 +1,6 @@
 import KSUID from 'ksuid';
 import * as crypto from 'node:crypto';
 export const Model = {
-    Action: {
-        UIDPrefix: 'act',
-    },
     Notification: {
         UIDPrefix: 'ntf',
     },

package/dist/esm/workspace/utils.test.d.ts

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

package/dist/esm/workspace/utils.test.d.ts.map

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

package/dist/esm/workspace/utils.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generateHandle, generateNotificationId, generateTenantId, } from './utils.js';
+describe('Workspace - Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct UID prefixes', () => {
+            expect(Model.Notification.UIDPrefix).toBe('ntf');
+            expect(Model.Tenant.UIDPrefix).toBe('tnt');
+        });
+    });
+    describe('generateTenantId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateTenantId();
+            expect(id).toMatch(/^tnt_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateTenantId();
+            const id2 = generateTenantId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateTenantId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+    describe('generateHandle', () => {
+        test('should generate 12-character hex string', () => {
+            const handle = generateHandle();
+            expect(handle).toMatch(/^[a-f0-9]{12}$/);
+            expect(handle.length).toBe(12);
+        });
+        test('should generate unique handles', () => {
+            const handle1 = generateHandle();
+            const handle2 = generateHandle();
+            expect(handle1).not.toBe(handle2);
+        });
+        test('should only contain lowercase hex characters', () => {
+            const handle = generateHandle();
+            expect(handle).toMatch(/^[a-f0-9]+$/);
+        });
+        test('should generate consistent length handles', () => {
+            const handles = Array.from({ length: 10 }, () => generateHandle());
+            const lengths = handles.map((h) => h.length);
+            expect(lengths.every((l) => l === 12)).toBe(true);
+        });
+    });
+    describe('generateNotificationId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateNotificationId();
+            expect(id).toMatch(/^ntf_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateNotificationId();
+            const id2 = generateNotificationId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateNotificationId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-mondo/identity-sdk",
-  "version": "0.0.2-beta.7",
+  "version": "0.0.2-beta.71",
   "type": "module",
   "description": "A node SDK for Mondo Identity",
   "license": "MIT",
@@ -133,8 +133,8 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "arktype": "^2.1.20",
-    "ksuid": "^3.0.0"
+    "ksuid": "^3.0.0",
+    "zod": "^4.0.17"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",

package/src/action/schema/operations/sign-up-verification.test.ts.bak

@@ -0,0 +1,163 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  SignUpVerificationActionPayloadSchema,
+  SignUpVerificationActionRequestSchema,
+} from './sign-up-verification.js';
+
+describe('Action Schema Operations - Sign Up Verification', () => {
+  describe('SignUpVerificationActionPayloadSchema', () => {
+    test('should accept complete payload', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept phoneNumber identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'phoneNumber' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid identifier', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'username',
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        // missing user, identifier, etc.
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up-verification' as const,
+        user: generateUserId(),
+        identifier: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('SignUpVerificationActionRequestSchema', () => {
+    test('should accept valid request', () => {
+      const request = {
+        code: 'verification_code_123',
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should reject missing code', () => {
+      const result = SignUpVerificationActionRequestSchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string code', () => {
+      const request = {
+        code: 123456,
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const request = {
+        code: 'verification_code_123',
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+      expect(result).toEqual({ code: 'verification_code_123' });
+    });
+  });
+});

package/src/action/schema/operations/sign-up.test.ts.bak

@@ -0,0 +1,203 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  SignUpActionPayloadSchema,
+  SignUpActionRequestSchema,
+} from './sign-up.js';
+
+describe('Action Schema Operations - Sign Up', () => {
+  describe('SignUpActionPayloadSchema', () => {
+    test('should accept complete payload with app', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        app: generateAppId(),
+        user: {
+          givenName: 'John',
+          familyName: 'Doe',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload without app', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {
+          givenName: 'Jane',
+          familyName: 'Smith',
+        },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal user name properties', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: {},
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: { givenName: 'John' },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        // missing user, attempt, etc.
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'sign-up' as const,
+        user: { givenName: 'John' },
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = SignUpActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('SignUpActionRequestSchema', () => {
+    test('should accept email sign up request', () => {
+      const request = {
+        id: generateUserId(),
+        email: 'john@example.com',
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept phone number sign up request', () => {
+      const request = {
+        id: generateUserId(),
+        phoneNumber: '+1234567890',
+        givenName: 'Jane',
+        familyName: 'Smith',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept request with both email and phone', () => {
+      const request = {
+        id: generateUserId(),
+        email: 'john@example.com',
+        phoneNumber: '+1234567890',
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept minimal request with just email', () => {
+      const request = {
+        email: 'minimal@example.com',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal request with just phone', () => {
+      const request = {
+        phoneNumber: '+1234567890',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject request without email or phone', () => {
+      const request = {
+        givenName: 'John',
+        familyName: 'Doe',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid email format', () => {
+      const request = {
+        email: 'invalid-email',
+        givenName: 'John',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should accept optional name properties', () => {
+      const request = {
+        email: 'john@example.com',
+        givenName: 'John',
+        familyName: 'Doe',
+        middleName: 'Michael',
+        honorificPrefix: 'Dr.',
+        honorificSuffix: 'Jr.',
+      };
+
+      const result = SignUpActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/action/schema/operations/user-attribute-verification.test.ts.bak

@@ -0,0 +1,148 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import {
+  UserAttributeVerificationActionPayloadSchema,
+  UserAttributeVerificationActionRequestSchema,
+} from './user-attribute-verification.js';
+
+describe('Action Schema Operations - User Attribute Verification', () => {
+  describe('UserAttributeVerificationActionPayloadSchema', () => {
+    test('should accept complete payload with email attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { key: 'value' },
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with phoneNumber attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'phoneNumber' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 2,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid operation', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'invalid-operation',
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid attribute', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'username',
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        // missing user, attribute, attempt, etc.
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should delete undeclared keys', () => {
+      const payload = {
+        id: generateActionId(),
+        operation: 'user-attribute-verification' as const,
+        user: generateUserId(),
+        attribute: 'email' as const,
+        attempt: 1,
+        expiresAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+        extraField: 'should be removed',
+      };
+
+      const result = UserAttributeVerificationActionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+    });
+  });
+
+  describe('UserAttributeVerificationActionRequestSchema', () => {
+    test('should accept empty request', () => {
+      const request = {};
+
+      const result = UserAttributeVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should delete undeclared keys', () => {
+      const request = {
+        extraField: 'should be removed',
+        anotherField: 'also removed',
+      };
+
+      const result = UserAttributeVerificationActionRequestSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).not.toHaveProperty('extraField');
+      expect(result).not.toHaveProperty('anotherField');
+      expect(result).toEqual({});
+    });
+  });
+});