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

package/src/authorization/roles/schema.test.ts.bak

@@ -1,283 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { generateAppId } from '../../app/utils.js';
-import { generateUserId } from '../../customer/schema.js';
-import { generatePermissionId, generateRoleId } from '../schema.js';
-import {
-  type InsertRolePayload,
-  InsertRolePayloadSchema,
-  type RoleAssociationReference,
-  RoleAssociationReferenceSchema,
-  RoleAssociationsSchema,
-  RoleIdPropertySchema,
-  RoleSchema,
-  RoleStatus,
-  UpdateRolePayloadSchema,
-} from './schema.js';
-
-describe('Authorization Roles - Schema', () => {
-  describe('RoleStatus constants', () => {
-    test('should have correct status values', () => {
-      expect(RoleStatus.ENABLED).toBe('enabled');
-      expect(RoleStatus.DISABLED).toBe('disabled');
-    });
-  });
-
-  describe('RoleIdPropertySchema', () => {
-    test('should accept valid id property', () => {
-      const payload = { id: generateRoleId() };
-      const result = RoleIdPropertySchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({ id: payload.id });
-    });
-
-    test('should reject missing id', () => {
-      const result = RoleIdPropertySchema({});
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('RoleAssociationsSchema', () => {
-    test('should accept valid associations', () => {
-      const payload = {
-        apps: [generateAppId(), generateAppId()],
-        permissions: [generatePermissionId(), generatePermissionId()],
-        users: [generateUserId(), generateUserId()],
-      };
-
-      const result = RoleAssociationsSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        apps: payload.apps,
-        permissions: payload.permissions,
-        users: payload.users,
-      });
-    });
-
-    test('should accept optional associations', () => {
-      const result = RoleAssociationsSchema({});
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({});
-    });
-
-    test('should accept partial associations', () => {
-      const result = RoleAssociationsSchema({
-        permissions: [generatePermissionId()],
-        users: undefined,
-      });
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject non-array associations', () => {
-      const result = RoleAssociationsSchema({
-        apps: 'not-an-array',
-      });
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('RoleSchema', () => {
-    test('should accept complete role object', () => {
-      const role = {
-        id: generateRoleId(),
-        name: 'admin',
-        status: 'enabled' as const,
-        description: 'Administrator role',
-        apps: { ids: [generateAppId()], count: 1 },
-        users: { ids: [generateUserId()], count: 1 },
-        permissions: { ids: [generatePermissionId()], count: 1 },
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { key: 'value' },
-      };
-
-      const result = RoleSchema(role);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept minimal role object', () => {
-      const role = {
-        id: generateRoleId(),
-        name: 'user',
-        status: 'enabled' as const,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = RoleSchema(role);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept role with optional dates', () => {
-      const role = {
-        id: generateRoleId(),
-        name: 'user',
-        status: 'disabled' as const,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: new Date(),
-        deactivatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = RoleSchema(role);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should reject invalid status', () => {
-      const role = {
-        id: generateRoleId(),
-        name: 'admin',
-        status: 'invalid',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: {},
-      };
-
-      const result = RoleSchema(role);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject missing required fields', () => {
-      const role = {
-        id: generateRoleId(),
-        name: 'admin',
-      };
-
-      const result = RoleSchema(role);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('InsertRolePayloadSchema', () => {
-    test('should accept complete insert payload', () => {
-      const payload = {
-        id: generateRoleId(),
-        name: 'admin',
-        status: 'enabled' as const,
-        description: 'Administrator role',
-        apps: [generateAppId()],
-        permissions: [generatePermissionId()],
-        users: [generateUserId()],
-        metadata: { key: 'value' },
-      };
-
-      const result = InsertRolePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-
-    test('should accept minimal insert payload', () => {
-      const payload = {
-        name: 'user',
-      };
-
-      const result = InsertRolePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect((result as InsertRolePayload).status).toBe('enabled'); // default value
-    });
-
-    test('should generate default ID when not provided', () => {
-      const payload = { name: 'admin' };
-      const result = InsertRolePayloadSchema(payload);
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect((result as InsertRolePayload).id).toMatch(/^rol_/);
-    });
-
-    test('should reject missing name', () => {
-      const result = InsertRolePayloadSchema({});
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should accept associations in insert payload', () => {
-      const payload = {
-        name: 'moderator',
-        apps: [generateAppId(), generateAppId()],
-        permissions: [generatePermissionId(), generatePermissionId()],
-        users: [generateUserId()],
-      };
-
-      const result = InsertRolePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('UpdateRolePayloadSchema', () => {
-    test('should accept all optional fields', () => {
-      const payload = {
-        name: 'updated-role',
-        status: 'disabled' as const,
-        description: 'Updated description',
-        metadata: { updated: true },
-      };
-
-      const result = UpdateRolePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should accept empty update payload', () => {
-      const result = UpdateRolePayloadSchema({});
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({});
-    });
-
-    test('should accept partial updates', () => {
-      const payload = { name: 'new-name' };
-      const result = UpdateRolePayloadSchema(payload);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(payload);
-    });
-
-    test('should reject invalid status', () => {
-      const payload = { status: 'invalid-status' };
-      const result = UpdateRolePayloadSchema(payload);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('RoleAssociationReferenceSchema', () => {
-    test('should accept complete association reference', () => {
-      const reference = {
-        id: generateRoleId(),
-        name: 'admin',
-        status: 'enabled' as const,
-        model: 'Role' as const,
-      };
-
-      const result = RoleAssociationReferenceSchema(reference);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual(reference);
-    });
-
-    test('should use default status when not provided', () => {
-      const reference = {
-        id: generateRoleId(),
-        name: 'admin',
-        model: 'Role' as const,
-      };
-
-      const result = RoleAssociationReferenceSchema(reference);
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect((result as RoleAssociationReference).status).toBe('disabled'); // default value
-    });
-
-    test('should reject missing required fields', () => {
-      const reference = { id: generateRoleId() };
-      const result = RoleAssociationReferenceSchema(reference);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject invalid model value', () => {
-      const reference = {
-        id: generateRoleId(),
-        name: 'admin',
-        model: 'InvalidModel',
-      };
-
-      const result = RoleAssociationReferenceSchema(reference);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-});

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

@@ -1,89 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { AggregateSchema } from './aggregate.js';
-
-describe('Common Schema - Aggregate', () => {
-  describe('AggregateSchema', () => {
-    test('should accept valid aggregate with ids and count', () => {
-      const result = AggregateSchema({
-        ids: ['id1', 'id2', 'id3'],
-        count: 25,
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        ids: ['id1', 'id2', 'id3'],
-        count: 25,
-      });
-    });
-
-    test('should accept aggregate with only ids', () => {
-      const result = AggregateSchema({
-        ids: ['id1', 'id2'],
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        ids: ['id1', 'id2'],
-      });
-    });
-
-    test('should accept aggregate with only count', () => {
-      const result = AggregateSchema({
-        count: 42,
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        count: 42,
-      });
-    });
-
-    test('should accept empty aggregate', () => {
-      const result = AggregateSchema({});
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({});
-    });
-
-    test('should accept aggregate with empty ids array', () => {
-      const result = AggregateSchema({
-        ids: [],
-        count: 0,
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        ids: [],
-        count: 0,
-      });
-    });
-
-    test('should reject invalid ids type', () => {
-      const result = AggregateSchema({
-        ids: 'not-an-array',
-        count: 10,
-      });
-
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject invalid count type', () => {
-      const result = AggregateSchema({
-        ids: ['id1'],
-        count: 'not-a-number',
-      });
-
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject non-string items in ids array', () => {
-      const result = AggregateSchema({
-        ids: ['id1', 123, 'id3'],
-        count: 3,
-      });
-
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-});

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

@@ -1,116 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { CollectionSchema, PaginationCollectionSchema } from './collection.js';
-
-describe('Common Schema - Collection', () => {
-  describe('CollectionSchema', () => {
-    test('should accept valid collection with string items', () => {
-      const StringCollectionSchema = CollectionSchema('string');
-      const result = StringCollectionSchema({
-        items: ['item1', 'item2', 'item3'],
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: ['item1', 'item2', 'item3'],
-      });
-    });
-
-    test('should accept valid collection with number items', () => {
-      const NumberCollectionSchema = CollectionSchema('number');
-      const result = NumberCollectionSchema({
-        items: [1, 2, 3],
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: [1, 2, 3],
-      });
-    });
-
-    test('should accept empty collection', () => {
-      const StringCollectionSchema = CollectionSchema('string');
-      const result = StringCollectionSchema({
-        items: [],
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: [],
-      });
-    });
-
-    test('should reject invalid items type', () => {
-      const StringCollectionSchema = CollectionSchema('string');
-      const result = StringCollectionSchema({
-        items: 'not-an-array',
-      });
-
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-
-  describe('PaginationCollectionSchema', () => {
-    test('should accept valid paginated collection', () => {
-      const StringPaginationCollectionSchema =
-        PaginationCollectionSchema('string');
-      const result = StringPaginationCollectionSchema({
-        items: ['item1', 'item2'],
-        pagination: {
-          pageSize: '10',
-          nextToken: 'token123',
-        },
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: ['item1', 'item2'],
-        pagination: {
-          pageSize: '10',
-          nextToken: 'token123',
-        },
-      });
-    });
-
-    test('should accept collection without pagination', () => {
-      const StringPaginationCollectionSchema =
-        PaginationCollectionSchema('string');
-      const result = StringPaginationCollectionSchema({
-        items: ['item1', 'item2'],
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: ['item1', 'item2'],
-      });
-    });
-
-    test('should accept collection with empty pagination', () => {
-      const StringPaginationCollectionSchema =
-        PaginationCollectionSchema('string');
-      const result = StringPaginationCollectionSchema({
-        items: ['item1'],
-        pagination: {},
-      });
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toEqual({
-        items: ['item1'],
-        pagination: {},
-      });
-    });
-
-    test('should reject invalid pagination', () => {
-      const StringPaginationCollectionSchema =
-        PaginationCollectionSchema('string');
-      const result = StringPaginationCollectionSchema({
-        items: ['item1'],
-        pagination: {
-          pageSize: true,
-        },
-      });
-
-      expect(result).toBeInstanceOf(type.errors);
-    });
-  });
-});

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

@@ -1,49 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
-
-describe('Common - Dates', () => {
-  describe('Date Schema', () => {
-    test('should accept an iso string', async () => {
-      const result = RequiredDateSchema(
-        new Date().toISOString()
-      ) as typeof RequiredDateSchema.inferOut;
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toBeInstanceOf(Date);
-    });
-
-    test('should accept a Date object', async () => {
-      const result = RequiredDateSchema(
-        new Date()
-      ) as typeof RequiredDateSchema.inferOut;
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).toBeInstanceOf(Date);
-    });
-  });
-
-  describe('Payload Schema', () => {
-    test('should parse a Date to an ISO string', async () => {
-      const iso = new Date().toISOString();
-
-      const result = RequiredDatePayloadSchema(
-        new Date(iso)
-      ) as typeof RequiredDatePayloadSchema.inferOut;
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).to.equal(iso);
-    });
-
-    test('should parse an ISO to an ISO string', async () => {
-      const iso = new Date().toISOString();
-
-      const result = RequiredDatePayloadSchema(
-        iso
-      ) as typeof RequiredDatePayloadSchema.inferOut;
-
-      expect(result).not.toBeInstanceOf(type.errors);
-      expect(result).to.equal(iso);
-    });
-  });
-});

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

@@ -1,149 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { KSUIDSchema } from './id.js';
-
-describe('Common Schema - ID', () => {
-  describe('KSUIDSchema', () => {
-    test('should accept valid KSUID with correct prefix', () => {
-      const schema = KSUIDSchema('usr');
-      const validId = 'usr_123456789012345678901234567';
-
-      const result = schema(validId);
-      expect(result).toBe(validId);
-    });
-
-    test('should accept KSUID with different prefixes', () => {
-      const userSchema = KSUIDSchema('usr');
-      const appSchema = KSUIDSchema('app');
-      const activitySchema = KSUIDSchema('act');
-
-      const userId = 'usr_abcdefghijklmnopqrstuvwxy12';
-      const appId = 'app_1234567890ABCDEFGHIJKLMNOP1';
-      const activityId = 'act_abcDEF123456789012345678901';
-
-      expect(userSchema(userId)).toBe(userId);
-      expect(appSchema(appId)).toBe(appId);
-      expect(activitySchema(activityId)).toBe(activityId);
-    });
-
-    test('should accept KSUID with mixed alphanumeric characters', () => {
-      const schema = KSUIDSchema('test');
-      const mixedId = 'test_1a2B3c4D5e6F7g8H9i0JkLmNoPq';
-
-      const result = schema(mixedId);
-      expect(result).toBe(mixedId);
-    });
-
-    test('should reject KSUID with wrong prefix', () => {
-      const schema = KSUIDSchema('usr');
-      const wrongPrefixId = 'app_123456789012345678901234567';
-
-      const result = schema(wrongPrefixId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with missing prefix', () => {
-      const schema = KSUIDSchema('usr');
-      const noPrefixId = '123456789012345678901234567';
-
-      const result = schema(noPrefixId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with missing underscore', () => {
-      const schema = KSUIDSchema('usr');
-      const noUnderscoreId = 'usr123456789012345678901234567';
-
-      const result = schema(noUnderscoreId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with incorrect suffix length (too short)', () => {
-      const schema = KSUIDSchema('usr');
-      const shortId = 'usr_12345678901234567890123456';
-
-      const result = schema(shortId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with incorrect suffix length (too long)', () => {
-      const schema = KSUIDSchema('usr');
-      const longId = 'usr_1234567890123456789012345678';
-
-      const result = schema(longId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with invalid characters in suffix', () => {
-      const schema = KSUIDSchema('usr');
-      const invalidCharsId = 'usr_123456789012345678901234_*';
-
-      const result = schema(invalidCharsId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with special characters in suffix', () => {
-      const schema = KSUIDSchema('usr');
-      const specialCharsId = 'usr_12345678901234567890123456@';
-
-      const result = schema(specialCharsId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject KSUID with spaces', () => {
-      const schema = KSUIDSchema('usr');
-      const spaceId = 'usr_1234567890123456789012345 7';
-
-      const result = schema(spaceId);
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject empty string', () => {
-      const schema = KSUIDSchema('usr');
-
-      const result = schema('');
-      expect(result).toBeInstanceOf(type.errors);
-    });
-
-    test('should reject non-string values', () => {
-      const schema = KSUIDSchema('usr');
-
-      expect(schema(123)).toBeInstanceOf(type.errors);
-      expect(schema(null)).toBeInstanceOf(type.errors);
-      expect(schema(undefined)).toBeInstanceOf(type.errors);
-      expect(schema({})).toBeInstanceOf(type.errors);
-    });
-
-    test('should work with complex prefixes', () => {
-      const complexSchema = KSUIDSchema('app_config');
-      const validComplexId = 'app_config_123456789012345678901234567';
-
-      const result = complexSchema(validComplexId);
-      expect(result).toBe(validComplexId);
-    });
-
-    test('should work with single character prefix', () => {
-      const singleCharSchema = KSUIDSchema('a');
-      const validSingleCharId = 'a_123456789012345678901234567';
-
-      const result = singleCharSchema(validSingleCharId);
-      expect(result).toBe(validSingleCharId);
-    });
-
-    test('should create different schemas for different prefixes', () => {
-      const userSchema = KSUIDSchema('usr');
-      const orgSchema = KSUIDSchema('org');
-
-      const userId = 'usr_123456789012345678901234567';
-      const orgId = 'org_123456789012345678901234567';
-
-      // User schema should accept user ID but reject org ID
-      expect(userSchema(userId)).toBe(userId);
-      expect(userSchema(orgId)).toBeInstanceOf(type.errors);
-
-      // Org schema should accept org ID but reject user ID
-      expect(orgSchema(orgId)).toBe(orgId);
-      expect(orgSchema(userId)).toBeInstanceOf(type.errors);
-    });
-  });
-});