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

package/src/common/schema/sets.test.ts.bak

@@ -0,0 +1,108 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  UniqueStringSetPayloadSchema,
+  UniqueStringPayloadSchema,
+} from './sets.js';
+
+describe('Common Schema - Sets', () => {
+  describe('UniqueStringSetPayloadSchema', () => {
+    test('should accept Set of strings', () => {
+      const stringSet = new Set(['a', 'b', 'c']);
+      const result = UniqueStringSetPayloadSchema(stringSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should accept array of strings and convert to Set', () => {
+      const stringArray = ['x', 'y', 'z'];
+      const result = UniqueStringSetPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['x', 'y', 'z']);
+    });
+
+    test('should handle duplicate strings in array', () => {
+      const stringArray = ['a', 'b', 'a', 'c', 'b'];
+      const result = UniqueStringSetPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should accept empty array', () => {
+      const result = UniqueStringSetPayloadSchema([]);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect((result as Set<string>).size).toBe(0);
+    });
+
+    test('should accept empty Set', () => {
+      const emptySet = new Set<string>();
+      const result = UniqueStringSetPayloadSchema(emptySet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect((result as Set<string>).size).toBe(0);
+    });
+
+    test('should reject non-string array elements', () => {
+      const result = UniqueStringSetPayloadSchema(['a', 123, 'b']);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-array, non-Set values', () => {
+      expect(UniqueStringSetPayloadSchema('string')).toBeInstanceOf(
+        type.errors
+      );
+      expect(UniqueStringSetPayloadSchema(123)).toBeInstanceOf(type.errors);
+      expect(UniqueStringSetPayloadSchema({})).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UniqueStringPayloadSchema', () => {
+    test('should convert Set to array', () => {
+      const stringSet = new Set(['x', 'y', 'z']);
+      const result = UniqueStringPayloadSchema(stringSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(Array.isArray(result)).toBe(true);
+      expect((result as string[]).sort()).toEqual(['x', 'y', 'z']);
+    });
+
+    test('should convert array to unique array', () => {
+      const stringArray = ['a', 'b', 'a', 'c', 'b'];
+      const result = UniqueStringPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(Array.isArray(result)).toBe(true);
+      expect((result as string[]).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should handle empty inputs', () => {
+      const emptySet = new Set<string>();
+      const emptyArray: string[] = [];
+
+      const setResult = UniqueStringPayloadSchema(emptySet);
+      const arrayResult = UniqueStringPayloadSchema(emptyArray);
+
+      expect(setResult).not.toBeInstanceOf(type.errors);
+      expect(arrayResult).not.toBeInstanceOf(type.errors);
+      expect((setResult as string[]).length).toBe(0);
+      expect((arrayResult as string[]).length).toBe(0);
+    });
+
+    test('should maintain order from original Set', () => {
+      const orderedSet = new Set(['first', 'second', 'third']);
+      const result = UniqueStringPayloadSchema(orderedSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(['first', 'second', 'third']);
+    });
+  });
+});

package/src/customer/users/schema.test.ts.bak

@@ -0,0 +1,138 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../schema.js';
+import {
+  InsertUserPayloadSchema,
+  UserPayloadSchema,
+  UserStatus,
+} from './schema.js';
+
+describe('Customer - User', () => {
+  describe('User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        status: UserStatus.ACTIVE,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      const result = UserPayloadSchema(
+        item
+      ) as typeof UserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+    });
+  });
+
+  describe('Insert User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        familyName: 'Foo',
+        phoneNumber: '123',
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+      expect(result?.familyName).to.equal(item.familyName);
+    });
+
+    test('should serialize successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        metadata: new Map(),
+        // status: UserStatus.ACTIVE,
+        // createdAt: new Date(),
+        // updatedAt: new Date(),
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.null;
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const test = type({
+        foo: 'string.numeric.parse',
+        bar: 'number',
+        baz: 'string.date.iso.parse',
+      });
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/identity/schema.test.ts.bak

@@ -0,0 +1,48 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { IdentityIdentifier, IdentityIdentifierSchema } from './schema.js';
+
+describe('Identity - Schema', () => {
+  describe('IdentityIdentifier constants', () => {
+    test('should have correct identifier values', () => {
+      expect(IdentityIdentifier.EMAIL).toBe('email');
+      expect(IdentityIdentifier.PHONE_NUMBER).toBe('phoneNumber');
+    });
+  });
+
+  describe('IdentityIdentifierSchema', () => {
+    test('should accept valid email identifier', () => {
+      const result = IdentityIdentifierSchema('email');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('email');
+    });
+
+    test('should accept valid phone number identifier', () => {
+      const result = IdentityIdentifierSchema('phoneNumber');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('phoneNumber');
+    });
+
+    test('should reject invalid identifiers', () => {
+      expect(IdentityIdentifierSchema('username')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('invalid')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(IdentityIdentifierSchema(123)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(null)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(undefined)).toBeInstanceOf(type.errors);
+    });
+
+    test('should be case sensitive', () => {
+      expect(IdentityIdentifierSchema('Email')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('PHONE_NUMBER')).toBeInstanceOf(
+        type.errors
+      );
+      expect(IdentityIdentifierSchema('phonenumber')).toBeInstanceOf(
+        type.errors
+      );
+    });
+  });
+});

package/src/oauth/token/schema/schema.test.ts.bak

@@ -0,0 +1,142 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { Schema } from './schema.js';
+
+describe('OAuth Token - Schema', () => {
+  describe('Schema union', () => {
+    test('should accept authorization code grant', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with PKCE', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+        code_verifier: 'pkce_verifier_123',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with client secret', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept client credentials grant', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read write',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept refresh token grant', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        refresh_token: 'refresh_token_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid grant type', () => {
+      const payload = {
+        grant_type: 'invalid_grant',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject authorization code without required fields', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        client_id: generateAppId(),
+        // missing code and redirect_uri
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid redirect URI', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'not-a-valid-url',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject client credentials without required fields', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        // missing client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject refresh token without required fields', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        client_id: 'app_123',
+        // missing refresh_token and client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject completely invalid payload', () => {
+      const payload = {
+        invalid: 'data',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/workspace/settings/schema.test.ts.bak

@@ -0,0 +1,88 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  SettingsPayloadSchema,
+  UpsertSettingsPayloadSchema,
+} from './schema.js';
+
+describe('Workspace Settings - Schema', () => {
+  describe('SettingsPayloadSchema', () => {
+    test('should accept complete settings payload', () => {
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: { version: '1.0', theme: 'dark' },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept minimal settings payload', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with some optional dates', () => {
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        metadata: { lastModified: 'now' },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept payload with only metadata', () => {
+      const payload = {
+        metadata: {
+          preferences: 'yes',
+        },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid date format', () => {
+      const payload = {
+        updatedAt: 'invalid-date',
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpsertSettingsPayloadSchema', () => {
+    test('should accept metadata for upsert', () => {
+      const payload = {
+        metadata: {
+          settings: 'light',
+        },
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept empty metadata', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+  });
+});