@go-mondo/identity-sdk 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/esm/authorization/permissions/schema.test.js

@@ -0,0 +1,215 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../app/utils.js';
+import { PermissionIdSchema, generatePermissionId, generateRoleId, } from '../schema.js';
+import { InsertPermissionPayloadSchema, 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',
+                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',
+                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',
+                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.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.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',
+                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',
+                model: 'Permission',
+            };
+            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',
+            };
+            const result = PermissionAssociationReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.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);
+        });
+    });
+});

package/dist/esm/authorization/roles/schema.d.ts

@@ -34,7 +34,7 @@ export declare const RoleSchema: import("arktype/internal/methods/object.ts").Ob
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
 }, {}>;
 export type RoleProperties = typeof RoleSchema.inferIn;
 export type Role = typeof RoleSchema.inferOut;
@@ -81,7 +81,7 @@ export declare const InsertRolePayloadSchema: import("arktype/internal/methods/o
         [x: string]: string | number | boolean;
     } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
         [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
+    } | null>) | undefined;
 }, {}>;
 export type InsertRoleInput = typeof InsertRolePayloadSchema.inferIn;
 export type InsertRolePayload = typeof InsertRolePayloadSchema.inferOut;
@@ -96,7 +96,7 @@ export declare const UpdateRolePayloadSchema: import("arktype/internal/methods/o
         [x: string]: string | number | boolean;
     } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
         [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
+    } | null>) | undefined;
 }, {}>;
 export type UpdateRoleInput = typeof UpdateRolePayloadSchema.inferIn;
 export type UpdateRolePayload = typeof UpdateRolePayloadSchema.inferOut;

package/dist/esm/authorization/roles/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/roles/schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAIzE,eAAO,MAAM,oBAAoB;;MAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAMlE,eAAO,MAAM,sBAAsB;;;;MAIjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAWtE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;MAOU,CAAC;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC,OAAO,CAAC;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,QAAQ,CAAC;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;MAOO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;MAOC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;MAIC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;MAIzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/roles/schema.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEzE,eAAO,MAAM,oBAAoB;;MAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAIlE,eAAO,MAAM,sBAAsB;;;;MAIjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAWtE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;MAOU,CAAC;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC,OAAO,CAAC;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,QAAQ,CAAC;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;MAOO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;MAOO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;MAIO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;MAIzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

package/dist/esm/authorization/roles/schema.js

@@ -1,22 +1,22 @@
 import { type } from 'arktype';
+import { AppIdAssociationsSchema } from '../../app/schema.js';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/index.js';
 import { AggregateSchema } from '../../common/schema/aggregate.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-import { generateRoleId } from '../utils.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+import { UserIdAssociationsSchema } from '../../customer/schema.js';
+import { PermissionIdAssociationsSchema, RoleIdSchema, generateRoleId, } from '../schema.js';
 export const RoleStatus = {
     ENABLED: 'enabled',
     DISABLED: 'disabled',
 };
-const RoleIdSchema = type.string;
 export const RoleIdPropertySchema = type({
     id: RoleIdSchema,
 });
 const StatusSchema = type.enumerated(RoleStatus.ENABLED, RoleStatus.DISABLED);
-const AssociationSchema = type('string[] | undefined');
 export const RoleAssociationsSchema = type({
-    apps: AssociationSchema.optional(),
-    permissions: AssociationSchema.optional(),
-    users: AssociationSchema.optional(),
+    apps: AppIdAssociationsSchema.optional(),
+    permissions: PermissionIdAssociationsSchema.optional(),
+    users: UserIdAssociationsSchema.optional(),
 });
 const BaseSchema = RoleIdPropertySchema.and({
     name: type('string'),
@@ -52,7 +52,7 @@ export const InsertRolePayloadSchema = type({
     description: type('string').optional(),
 })
     .and(RoleAssociationsSchema)
-    .and(MetadataPayloadPropertySchema);
+    .and(UpsertMetadataPropertyPayloadSchema);
 /**
  * Update
  */
@@ -60,7 +60,7 @@ export const UpdateRolePayloadSchema = type({
     name: type('string').optional(),
     status: StatusSchema.optional(),
     description: type('string').optional(),
-}).and(MetadataPayloadPropertySchema);
+}).and(UpsertMetadataPropertyPayloadSchema);
 /**
  * Association
  */

package/dist/esm/authorization/roles/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/esm/authorization/roles/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../../../src/authorization/roles/schema.test.ts"],"names":[],"mappings":""}

package/dist/esm/authorization/roles/schema.test.js

@@ -0,0 +1,234 @@
+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 { InsertRolePayloadSchema, 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',
+                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',
+                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',
+                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',
+                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.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.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',
+                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',
+                model: 'Role',
+            };
+            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',
+            };
+            const result = RoleAssociationReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.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/dist/esm/authorization/schema.d.ts

@@ -0,0 +1,17 @@
+export declare const Model: {
+    readonly Permission: {
+        readonly UIDPrefix: "per";
+    };
+    readonly Role: {
+        readonly UIDPrefix: "rol";
+    };
+};
+export declare function generatePermissionId(): string;
+export declare function generateRoleId(): string;
+export declare const RoleIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type RoleId = typeof RoleIdSchema.inferOut;
+export declare const RoleIdAssociationsSchema: import("arktype").BaseType<string[] | undefined, {}>;
+export declare const PermissionIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type PermissionId = typeof PermissionIdSchema.inferOut;
+export declare const PermissionIdAssociationsSchema: import("arktype").BaseType<string[] | undefined, {}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/authorization/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/authorization/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,wBAAgB,oBAAoB,WAEnC;AAED,wBAAgB,cAAc,WAE7B;AAED,eAAO,MAAM,YAAY,qEAAoC,CAAC;AAC9D,MAAM,MAAM,MAAM,GAAG,OAAO,YAAY,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,wBAAwB,sDAEpC,CAAC;AAEF,eAAO,MAAM,kBAAkB,qEAA0C,CAAC;AAC1E,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,eAAO,MAAM,8BAA8B,sDAE1C,CAAC"}

package/dist/esm/authorization/schema.js

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+import KSUID from 'ksuid';
+import { KSUIDSchema } from '../common/schema/id.js';
+export const Model = {
+    Permission: {
+        UIDPrefix: 'per',
+    },
+    Role: {
+        UIDPrefix: 'rol',
+    },
+};
+export function generatePermissionId() {
+    return `${Model.Permission.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateRoleId() {
+    return `${Model.Role.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export const RoleIdSchema = KSUIDSchema(Model.Role.UIDPrefix);
+export const RoleIdAssociationsSchema = type('undefined').or(RoleIdSchema.array());
+export const PermissionIdSchema = KSUIDSchema(Model.Permission.UIDPrefix);
+export const PermissionIdAssociationsSchema = type('undefined').or(PermissionIdSchema.array());

package/dist/esm/authorization/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/esm/authorization/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../../src/authorization/schema.test.ts"],"names":[],"mappings":""}

package/dist/esm/authorization/schema.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generatePermissionId, generateRoleId } from './schema.js';
+describe('Authorization - Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct UID prefixes', () => {
+            expect(Model.Permission.UIDPrefix).toBe('per');
+            expect(Model.Role.UIDPrefix).toBe('rol');
+        });
+    });
+    describe('generatePermissionId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generatePermissionId();
+            expect(id).toMatch(/^per_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generatePermissionId();
+            const id2 = generatePermissionId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generatePermissionId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+    describe('generateRoleId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateRoleId();
+            expect(id).toMatch(/^rol_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateRoleId();
+            const id2 = generateRoleId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateRoleId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+});

package/dist/esm/common/errors/http.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=http.test.d.ts.map

package/dist/esm/common/errors/http.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.test.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/http.test.ts"],"names":[],"mappings":""}