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

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

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

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

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

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

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