@go-mondo/identity-sdk 0.0.2-beta.74 → 0.0.2-beta.76

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

@@ -1,174 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,267 +0,0 @@
-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);
-    });
-  });
-});