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

package/src/authentication/factors/schema.test.ts.bak

@@ -0,0 +1,174 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../utils.js';
+import {
+  AuthenticationFactorPayloadSchema,
+  AuthenticationFactorsPayloadSchema,
+  UpsertAuthenticationFactorsPayloadSchema,
+} from './schema.js';
+
+describe('Authentication - Factors', () => {
+  describe('Schema', () => {
+    test('should parse response payload successfully', async () => {
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          factors: [
+            {
+              id: generateStrategyId(),
+            },
+          ],
+        })
+      ).not.toBeInstanceOf(type.errors);
+
+      // Undefined factors
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          factors: undefined,
+        })
+      ).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should parse upsert payload successfully', async () => {
+      expect(
+        UpsertAuthenticationFactorsPayloadSchema({
+          factors: [
+            {
+              id: generateStrategyId(),
+            },
+          ],
+        })
+      ).not.toBeInstanceOf(type.errors);
+
+      // Null factors
+      expect(
+        UpsertAuthenticationFactorsPayloadSchema({
+          factors: null,
+        })
+      ).not.toBeInstanceOf(type.errors);
+
+      // Undefined factors
+      expect(
+        UpsertAuthenticationFactorsPayloadSchema({
+          factors: undefined,
+        })
+      ).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should throw error for invalid factors', async () => {
+      // Factor object
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          factors: { id: generateStrategyId() },
+        })
+      ).toBeInstanceOf(type.errors);
+
+      // Factor array of string
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          factors: [generateStrategyId()],
+        })
+      ).toBeInstanceOf(type.errors);
+    });
+
+    test('should accept various next factors types', async () => {
+      // Undefined
+      expect(
+        AuthenticationFactorPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: undefined,
+        })
+      ).not.toBeInstanceOf(type.errors);
+
+      // Array
+      expect(
+        AuthenticationFactorPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: [
+            {
+              id: generateStrategyId(),
+            },
+          ],
+        })
+      ).not.toBeInstanceOf(type.errors);
+
+      // Deeply nested array
+      expect(
+        AuthenticationFactorPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: [
+            {
+              id: generateStrategyId(),
+              nextFactors: [
+                {
+                  id: generateStrategyId(),
+                  nextFactors: [
+                    {
+                      id: generateStrategyId(),
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        })
+      ).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should throw error for invalid factor id', async () => {
+      // Number
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: generateStrategyId(),
+        })
+      ).toBeInstanceOf(type.errors);
+
+      // Null
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: null,
+        })
+      ).toBeInstanceOf(type.errors);
+
+      // Undefined
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: undefined,
+        })
+      ).toBeInstanceOf(type.errors);
+    });
+
+    test('should throw error for invalid next factors', async () => {
+      // String
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: generateStrategyId(),
+        })
+      ).toBeInstanceOf(type.errors);
+
+      // Object
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: { id: generateStrategyId() },
+        })
+      ).toBeInstanceOf(type.errors);
+
+      // Array
+      expect(
+        AuthenticationFactorsPayloadSchema({
+          id: generateStrategyId(),
+          nextFactors: [generateStrategyId()],
+        })
+      ).toBeInstanceOf(type.errors);
+    });
+  });
+});

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

@@ -0,0 +1,91 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  SettingsSchema,
+  SettingsPayloadSchema,
+  UpsertSettingsPayloadSchema,
+} from './schema.js';
+
+describe('Authentication Settings - Schema', () => {
+  describe('SettingsSchema', () => {
+    test('should accept minimal settings object', () => {
+      const settings = {
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = SettingsSchema(settings);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required dates', () => {
+      const settings = {
+        metadata: {},
+        // missing createdAt, updatedAt
+      };
+
+      const result = SettingsSchema(settings);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('SettingsPayloadSchema', () => {
+    test('should accept minimal payload', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with optional dates', () => {
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept empty payload', () => {
+      const payload = {
+        // Schema might have defaults for metadata
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpsertSettingsPayloadSchema', () => {
+    test('should accept empty upsert payload', () => {
+      const payload = {};
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept upsert with only metadata', () => {
+      const payload = {
+        metadata: { configVersion: '2.0' },
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid factors structure', () => {
+      const payload = {
+        factors: 'invalid-factors',
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/authentication/strategies/schema/types/email.test.ts.bak

@@ -0,0 +1,252 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../../../../authentication/utils.js';
+import {
+  EmailStrategyPayloadSchema,
+  EmailStrategySchema,
+  InsertEmailStrategyPayloadSchema,
+  SendEmailVerificationCodeSchema,
+  UpdateEmailStrategyPayloadSchema,
+  VerifyEmailSchema,
+} from './email.js';
+
+describe('Authentication Strategies - Email', () => {
+  describe('EmailStrategySchema', () => {
+    test('should accept complete email strategy', () => {
+      const strategy = {
+        id: generateStrategyId(),
+        type: 'email',
+        label: 'Test',
+        status: 'enabled',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: { provider: 'sendgrid' },
+      };
+
+      const result = EmailStrategySchema(strategy);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid type', () => {
+      const strategy = {
+        id: generateStrategyId(),
+        type: 'password',
+        status: 'enabled',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = EmailStrategySchema(strategy);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const strategy = {
+        type: 'email',
+        // missing id, enabled, dates, metadata
+      };
+
+      const result = EmailStrategySchema(strategy);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('EmailStrategyPayloadSchema', () => {
+    test('should accept complete payload', () => {
+      const payload = {
+        id: generateStrategyId(),
+        type: 'email',
+        label: 'Test',
+        status: 'enabled',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: { configured: true },
+      };
+
+      const result = EmailStrategyPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid type', () => {
+      const payload = {
+        id: generateStrategyId(),
+        type: 'sms',
+        label: 'Test',
+        status: 'enabled',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        metadata: {},
+      };
+
+      const result = EmailStrategyPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('InsertEmailStrategyPayloadSchema', () => {
+    test('should accept complete insert payload', () => {
+      const payload = {
+        id: generateStrategyId(),
+        type: 'email',
+        label: 'Test',
+        status: 'enabled',
+        metadata: { setup: 'manual' },
+      };
+
+      const result = InsertEmailStrategyPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal insert payload', () => {
+      const payload = {
+        type: 'email',
+        label: 'Test',
+      };
+
+      const result = InsertEmailStrategyPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing type', () => {
+      const payload = {
+        status: 'enabled',
+      };
+
+      const result = InsertEmailStrategyPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid type', () => {
+      const payload = {
+        type: 'password',
+      };
+
+      const result = InsertEmailStrategyPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpdateEmailStrategyPayloadSchema', () => {
+    test('should accept update with type and enabled', () => {
+      const payload = {
+        type: 'email',
+        enabled: false,
+        metadata: { updated: true },
+      };
+
+      const result = UpdateEmailStrategyPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept minimal update', () => {
+      const payload = {
+        type: 'email',
+      };
+
+      const result = UpdateEmailStrategyPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid type', () => {
+      const payload = {
+        type: 'totp',
+      };
+
+      const result = UpdateEmailStrategyPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('VerifyEmailSchema', () => {
+    test('should accept verification with email and code', () => {
+      const verification = {
+        email: 'user@example.com',
+        code: '123456',
+      };
+
+      const result = VerifyEmailSchema(verification);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(verification);
+    });
+
+    test('should accept verification with only code', () => {
+      const verification = {
+        code: 'ABC123',
+      };
+
+      const result = VerifyEmailSchema(verification);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(verification);
+    });
+
+    test('should reject missing code', () => {
+      const verification = {
+        email: 'user@example.com',
+      };
+
+      const result = VerifyEmailSchema(verification);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid email format', () => {
+      const verification = {
+        email: 'invalid-email',
+        code: '123456',
+      };
+
+      const result = VerifyEmailSchema(verification);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string code', () => {
+      const verification = {
+        email: 'user@example.com',
+        code: 123456,
+      };
+
+      const result = VerifyEmailSchema(verification);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('SendEmailVerificationCodeSchema', () => {
+    test('should accept valid email', () => {
+      const request = {
+        email: 'test@example.com',
+      };
+
+      const result = SendEmailVerificationCodeSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should accept empty request', () => {
+      const request = {};
+
+      const result = SendEmailVerificationCodeSchema(request);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(request);
+    });
+
+    test('should reject invalid email format', () => {
+      const request = {
+        email: 'not-an-email',
+      };
+
+      const result = SendEmailVerificationCodeSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string email', () => {
+      const request = {
+        email: 123,
+      };
+
+      const result = SendEmailVerificationCodeSchema(request);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});