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

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/authorization/permissions/schema.test.ts.bak

@@ -0,0 +1,267 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../app/utils.js';
+import {
+  PermissionIdSchema,
+  generatePermissionId,
+  generateRoleId,
+} from '../schema.js';
+import {
+  type InsertPermissionPayload,
+  InsertPermissionPayloadSchema,
+  type PermissionAssociationReference,
+  PermissionAssociationReferenceSchema,
+  PermissionAssociationsSchema,
+  PermissionIdPropertySchema,
+  PermissionSchema,
+  PermissionStatus,
+  UpdatePermissionPayloadSchema,
+} from './schema.js';
+
+describe('Authorization Permissions - Schema', () => {
+  describe('PermissionStatus constants', () => {
+    test('should have correct status values', () => {
+      expect(PermissionStatus.ENABLED).toBe('enabled');
+      expect(PermissionStatus.DISABLED).toBe('disabled');
+    });
+  });
+
+  describe('PermissionIdSchema', () => {
+    test('should accept valid string ID', () => {
+      const result = PermissionIdSchema(generatePermissionId());
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(PermissionIdSchema(123)).toBeInstanceOf(type.errors);
+      expect(PermissionIdSchema(null)).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('PermissionIdPropertySchema', () => {
+    test('should accept valid id property', () => {
+      const payload = { id: generatePermissionId() };
+      const result = PermissionIdPropertySchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({ id: payload.id });
+    });
+
+    test('should reject missing id', () => {
+      const result = PermissionIdPropertySchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('PermissionAssociationsSchema', () => {
+    const payload = {
+      apps: [generateAppId(), generateAppId()],
+      roles: [generateRoleId(), generateRoleId()],
+    };
+    test('should accept valid associations', () => {
+      const result = PermissionAssociationsSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({
+        apps: payload.apps,
+        roles: payload.roles,
+      });
+    });
+
+    test('should accept optional associations', () => {
+      const result = PermissionAssociationsSchema({});
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({});
+    });
+
+    test('should accept undefined associations', () => {
+      const result = PermissionAssociationsSchema({
+        apps: undefined,
+        roles: [generateRoleId()],
+      });
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-array associations', () => {
+      const result = PermissionAssociationsSchema({
+        apps: 'not-an-array',
+      });
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('PermissionSchema', () => {
+    test('should accept complete permission object', () => {
+      const permission = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'enabled' as const,
+        description: 'Read user data',
+        apps: { ids: [generateAppId()], count: 1 },
+        roles: { ids: [generateRoleId()], count: 1 },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: { key: 'value' },
+      };
+
+      const result = PermissionSchema(permission);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal permission object', () => {
+      const permission = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'enabled' as const,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = PermissionSchema(permission);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid status', () => {
+      const permission = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'invalid',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        metadata: {},
+      };
+
+      const result = PermissionSchema(permission);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject missing required fields', () => {
+      const permission = {
+        id: generatePermissionId(),
+        name: 'read:users',
+      };
+
+      const result = PermissionSchema(permission);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('InsertPermissionPayloadSchema', () => {
+    test('should accept complete insert payload', () => {
+      const payload = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'enabled' as const,
+        description: 'Read user data',
+        apps: [generateAppId()],
+        roles: [generateRoleId()],
+        metadata: { key: 'value' },
+      };
+
+      const result = InsertPermissionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept minimal insert payload', () => {
+      const payload = {
+        name: 'read:users',
+      };
+
+      const result = InsertPermissionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as InsertPermissionPayload).status).toBe('enabled'); // default value
+    });
+
+    test('should generate default ID when not provided', () => {
+      const payload = { name: 'read:users' };
+      const result = InsertPermissionPayloadSchema(payload);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as InsertPermissionPayload).id).toMatch(/^per_/);
+    });
+
+    test('should reject missing name', () => {
+      const result = InsertPermissionPayloadSchema({});
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpdatePermissionPayloadSchema', () => {
+    test('should accept all optional fields', () => {
+      const payload = {
+        name: 'updated:permission',
+        status: 'disabled' as const,
+        description: 'Updated description',
+        metadata: { updated: true },
+      };
+
+      const result = UpdatePermissionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept empty update payload', () => {
+      const result = UpdatePermissionPayloadSchema({});
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual({});
+    });
+
+    test('should accept partial updates', () => {
+      const payload = { name: 'new:name' };
+      const result = UpdatePermissionPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid status', () => {
+      const payload = { status: 'invalid-status' };
+      const result = UpdatePermissionPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('PermissionAssociationReferenceSchema', () => {
+    test('should accept complete association reference', () => {
+      const reference = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        status: 'enabled' as const,
+        model: 'Permission' as const,
+      };
+
+      const result = PermissionAssociationReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(reference);
+    });
+
+    test('should use default status when not provided', () => {
+      const reference = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        model: 'Permission' as const,
+      };
+
+      const result = PermissionAssociationReferenceSchema(reference);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect((result as PermissionAssociationReference).status).toBe(
+        'disabled'
+      ); // default value
+    });
+
+    test('should reject missing required fields', () => {
+      const reference = { id: generatePermissionId() };
+      const result = PermissionAssociationReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid model value', () => {
+      const reference = {
+        id: generatePermissionId(),
+        name: 'read:users',
+        model: 'InvalidModel',
+      };
+
+      const result = PermissionAssociationReferenceSchema(reference);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});