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

package/dist/esm/authentication/strategies/schema/types/email.test.d.ts.map

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

package/dist/esm/authentication/strategies/schema/types/email.test.js

@@ -0,0 +1,203 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../../../../authentication/utils.js';
+import { EmailStrategyPayloadSchema, EmailStrategySchema, InsertEmailStrategyPayloadSchema, SendEmailVerificationCodeSchema, UpdateEmailStrategyPayloadSchema, VerifyEmailSchema, } from './email.js';
+describe('Authentication Strategies - Email', () => {
+    describe('EmailStrategySchema', () => {
+        test('should accept complete email strategy', () => {
+            const strategy = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { provider: 'sendgrid' },
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const strategy = {
+                id: generateStrategyId(),
+                type: 'password',
+                status: 'enabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const strategy = {
+                type: 'email',
+                // missing id, enabled, dates, metadata
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('EmailStrategyPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { configured: true },
+            };
+            const result = EmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'sms',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = EmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertEmailStrategyPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                metadata: { setup: 'manual' },
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {
+                type: 'email',
+                label: 'Test',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing type', () => {
+            const payload = {
+                status: 'enabled',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'password',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateEmailStrategyPayloadSchema', () => {
+        test('should accept update with type and enabled', () => {
+            const payload = {
+                type: 'email',
+                enabled: false,
+                metadata: { updated: true },
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal update', () => {
+            const payload = {
+                type: 'email',
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'totp',
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('VerifyEmailSchema', () => {
+        test('should accept verification with email and code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(verification);
+        });
+        test('should accept verification with only code', () => {
+            const verification = {
+                code: 'ABC123',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(verification);
+        });
+        test('should reject missing code', () => {
+            const verification = {
+                email: 'user@example.com',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid email format', () => {
+            const verification = {
+                email: 'invalid-email',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: 123456,
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('SendEmailVerificationCodeSchema', () => {
+        test('should accept valid email', () => {
+            const request = {
+                email: 'test@example.com',
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should accept empty request', () => {
+            const request = {};
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should reject invalid email format', () => {
+            const request = {
+                email: 'not-an-email',
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string email', () => {
+            const request = {
+                email: 123,
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/strategies/schema/types/password.d.ts

@@ -34,7 +34,7 @@ export declare const PasswordStrategySchema: import("arktype/internal/methods/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>>;
     type: "password";
     settings: {
         passwordPolicy: {

package/dist/esm/authentication/strategies/schema/types/totp.d.ts

@@ -35,7 +35,7 @@ export declare const TOTPStrategySchema: import("arktype/internal/methods/object
     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>>;
     type: "totp";
     settings: {
         digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;

package/dist/esm/authentication/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const Model: {
+    readonly Strategy: {
+        readonly UIDPrefix: "stg";
+        readonly TYPE: "Strategy";
+    };
+    readonly Session: {
+        readonly UIDPrefix: "ssn";
+        readonly TYPE: "Session";
+    };
+};
+export declare function generateStrategyId(): string;
+export declare function generateSessionId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/authentication/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/authentication/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;CASR,CAAC;AAEX,wBAAgB,kBAAkB,WAEjC;AAED,wBAAgB,iBAAiB,WAEhC"}

package/dist/esm/authentication/utils.js

@@ -0,0 +1,17 @@
+import KSUID from 'ksuid';
+export const Model = {
+    Strategy: {
+        UIDPrefix: 'stg',
+        TYPE: 'Strategy',
+    },
+    Session: {
+        UIDPrefix: 'ssn',
+        TYPE: 'Session',
+    },
+};
+export function generateStrategyId() {
+    return `${Model.Strategy.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateSessionId() {
+    return `${Model.Session.UIDPrefix}_${KSUID.randomSync().string}`;
+}

package/dist/esm/authentication/utils.test.d.ts

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

package/dist/esm/authentication/utils.test.d.ts.map

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

package/dist/esm/authentication/utils.test.js

@@ -0,0 +1,140 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generateSessionId, generateStrategyId } from './utils.js';
+describe('Authentication Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct Strategy model properties', () => {
+            expect(Model.Strategy.UIDPrefix).toBe('stg');
+            expect(Model.Strategy.TYPE).toBe('Strategy');
+        });
+        test('should have correct Session model properties', () => {
+            expect(Model.Session.UIDPrefix).toBe('ssn');
+            expect(Model.Session.TYPE).toBe('Session');
+        });
+        test('should be readonly (const assertion)', () => {
+            // Test that the Model object is properly typed as const
+            expect(typeof Model).toBe('object');
+            expect(Object.isFrozen(Model)).toBe(false); // const assertion doesn't freeze at runtime
+        });
+    });
+    describe('generateStrategyId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateStrategyId();
+            expect(id).toMatch(/^stg_/);
+        });
+        test('should generate ID with correct format', () => {
+            const id = generateStrategyId();
+            // Should match: prefix + underscore + KSUID (27 characters)
+            expect(id).toMatch(/^stg_[A-Za-z0-9]{27}$/);
+        });
+        test('should generate unique IDs on multiple calls', () => {
+            const id1 = generateStrategyId();
+            const id2 = generateStrategyId();
+            const id3 = generateStrategyId();
+            expect(id1).not.toBe(id2);
+            expect(id2).not.toBe(id3);
+            expect(id1).not.toBe(id3);
+        });
+        test('should generate IDs with correct total length', () => {
+            const id = generateStrategyId();
+            // prefix (3) + underscore (1) + KSUID (27) = 31 characters
+            expect(id.length).toBe(31);
+        });
+        test('should generate IDs that start with strategy prefix', () => {
+            const ids = Array.from({ length: 10 }, () => generateStrategyId());
+            for (const id of ids) {
+                expect(id.startsWith('stg_')).toBe(true);
+            }
+        });
+        test('should generate KSUID-compatible format', () => {
+            const id = generateStrategyId();
+            const ksuidPart = id.substring(4); // Remove 'stg_'
+            // KSUID should be 27 characters of base62
+            expect(ksuidPart.length).toBe(27);
+            expect(ksuidPart).toMatch(/^[A-Za-z0-9]{27}$/);
+        });
+        test('should be deterministic in format but random in content', () => {
+            const ids = Array.from({ length: 100 }, () => generateStrategyId());
+            // All should have same format
+            for (const id of ids) {
+                expect(id).toMatch(/^stg_[A-Za-z0-9]{27}$/);
+            }
+            // All should be unique
+            const uniqueIds = new Set(ids);
+            expect(uniqueIds.size).toBe(100);
+        });
+    });
+    describe('generateSessionId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateSessionId();
+            expect(id).toMatch(/^ssn_/);
+        });
+        test('should generate ID with correct format', () => {
+            const id = generateSessionId();
+            // Should match: prefix + underscore + KSUID (27 characters)
+            expect(id).toMatch(/^ssn_[A-Za-z0-9]{27}$/);
+        });
+        test('should generate unique IDs on multiple calls', () => {
+            const id1 = generateSessionId();
+            const id2 = generateSessionId();
+            const id3 = generateSessionId();
+            expect(id1).not.toBe(id2);
+            expect(id2).not.toBe(id3);
+            expect(id1).not.toBe(id3);
+        });
+        test('should generate IDs with correct total length', () => {
+            const id = generateSessionId();
+            // prefix (3) + underscore (1) + KSUID (27) = 31 characters
+            expect(id.length).toBe(31);
+        });
+        test('should generate IDs that start with session prefix', () => {
+            const ids = Array.from({ length: 10 }, () => generateSessionId());
+            for (const id of ids) {
+                expect(id.startsWith('ssn_')).toBe(true);
+            }
+        });
+        test('should generate KSUID-compatible format', () => {
+            const id = generateSessionId();
+            const ksuidPart = id.substring(4); // Remove 'ssn_'
+            // KSUID should be 27 characters of base62
+            expect(ksuidPart.length).toBe(27);
+            expect(ksuidPart).toMatch(/^[A-Za-z0-9]{27}$/);
+        });
+        test('should be deterministic in format but random in content', () => {
+            const ids = Array.from({ length: 100 }, () => generateSessionId());
+            // All should have same format
+            for (const id of ids) {
+                expect(id).toMatch(/^ssn_[A-Za-z0-9]{27}$/);
+            }
+            // All should be unique
+            const uniqueIds = new Set(ids);
+            expect(uniqueIds.size).toBe(100);
+        });
+    });
+    describe('ID generation comparison', () => {
+        test('should generate different formats for strategy vs session', () => {
+            const strategyId = generateStrategyId();
+            const sessionId = generateSessionId();
+            expect(strategyId.startsWith('stg_')).toBe(true);
+            expect(sessionId.startsWith('ssn_')).toBe(true);
+            expect(strategyId).not.toBe(sessionId);
+        });
+        test('should maintain format consistency across generators', () => {
+            const strategyIds = Array.from({ length: 10 }, () => generateStrategyId());
+            const sessionIds = Array.from({ length: 10 }, () => generateSessionId());
+            // All strategy IDs should have same prefix
+            for (const id of strategyIds) {
+                expect(id.startsWith('stg_')).toBe(true);
+                expect(id.length).toBe(31);
+            }
+            // All session IDs should have same prefix
+            for (const id of sessionIds) {
+                expect(id.startsWith('ssn_')).toBe(true);
+                expect(id.length).toBe(31);
+            }
+            // No overlap between the two sets
+            const allIds = [...strategyIds, ...sessionIds];
+            const uniqueIds = new Set(allIds);
+            expect(uniqueIds.size).toBe(20);
+        });
+    });
+});

package/dist/esm/authorization/index.d.ts

@@ -2,5 +2,5 @@ export * from './permissions/resources.js';
 export * from './permissions/schema.js';
 export * from './roles/resources.js';
 export * from './roles/schema.js';
-export * from './utils.js';
+export * from './schema.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authorization/index.ts"],"names":[],"mappings":"AACA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AAGxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAElC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authorization/index.ts"],"names":[],"mappings":"AACA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AAGxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAElC,cAAc,aAAa,CAAC"}

package/dist/esm/authorization/index.js

@@ -4,4 +4,4 @@ export * from './permissions/schema.js';
 // Roles
 export * from './roles/resources.js';
 export * from './roles/schema.js';
-export * from './utils.js';
+export * from './schema.js';

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

@@ -3,7 +3,6 @@ export declare const PermissionStatus: {
     readonly DISABLED: "disabled";
 };
 export type AnyPermissionStatus = (typeof PermissionStatus)[keyof typeof PermissionStatus];
-export declare const PermissionIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
 export declare const PermissionIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
 }, {}>;
@@ -30,7 +29,7 @@ export declare const PermissionSchema: import("arktype/internal/methods/object.t
     } | undefined;
     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 PermissionProperties = typeof PermissionSchema.inferIn;
 export type Permission = typeof PermissionSchema.inferOut;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/permissions/schema.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,kBAAkB,qEAAc,CAAC;AAE9C,eAAO,MAAM,0BAA0B;;MAErC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAS9E,eAAO,MAAM,4BAA4B;;;MAGvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;AAQ/C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;MAOI,CAAC;AAClC,MAAM,MAAM,oBAAoB,GAAG,OAAO,gBAAgB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;MAOC,CAAC;AACtC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;MAOC,CAAC;AAC5C,MAAM,MAAM,qBAAqB,GAC/B,OAAO,6BAA6B,CAAC,OAAO,CAAC;AAC/C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;MAIC,CAAC;AAC5C,MAAM,MAAM,qBAAqB,GAC/B,OAAO,6BAA6B,CAAC,OAAO,CAAC;AAC/C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,oCAAoC;;;;;MAK7C,CAAC;AACL,MAAM,MAAM,8BAA8B,GACxC,OAAO,oCAAoC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authorization/permissions/schema.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,0BAA0B;;MAErC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAO9E,eAAO,MAAM,4BAA4B;;;MAGvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;AAQ/C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;MAOI,CAAC;AAClC,MAAM,MAAM,oBAAoB,GAAG,OAAO,gBAAgB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;MAOC,CAAC;AACtC,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;MAOC,CAAC;AAC5C,MAAM,MAAM,qBAAqB,GAC/B,OAAO,6BAA6B,CAAC,OAAO,CAAC;AAC/C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;MAIC,CAAC;AAC5C,MAAM,MAAM,qBAAqB,GAC/B,OAAO,6BAA6B,CAAC,OAAO,CAAC;AAC/C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD;;GAEG;AAEH,eAAO,MAAM,oCAAoC;;;;;MAK7C,CAAC;AACL,MAAM,MAAM,8BAA8B,GACxC,OAAO,oCAAoC,CAAC,QAAQ,CAAC"}

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

@@ -1,21 +1,20 @@
 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, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-import { generatePermissionId } from '../utils.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+import { PermissionIdSchema, RoleIdAssociationsSchema, generatePermissionId, } from '../schema.js';
 export const PermissionStatus = {
     ENABLED: 'enabled',
     DISABLED: 'disabled',
 };
-export const PermissionIdSchema = type.string;
 export const PermissionIdPropertySchema = type({
     id: PermissionIdSchema,
 });
 const PermissionStatusSchema = type.enumerated(PermissionStatus.ENABLED, PermissionStatus.DISABLED);
-const AssociationSchema = type('string[] | undefined');
 export const PermissionAssociationsSchema = type({
-    apps: AssociationSchema.optional(),
-    roles: AssociationSchema.optional(),
+    apps: AppIdAssociationsSchema.optional(),
+    roles: RoleIdAssociationsSchema.optional(),
 });
 const BaseSchema = PermissionIdPropertySchema.and({
     name: type('string'),
@@ -48,7 +47,7 @@ export const InsertPermissionPayloadSchema = type({
     description: type('string').optional(),
 })
     .and(PermissionAssociationsSchema)
-    .and(UpsertMetadataPayloadPropertySchema);
+    .and(UpsertMetadataPropertyPayloadSchema);
 /**
  * Update
  */
@@ -56,7 +55,7 @@ export const UpdatePermissionPayloadSchema = type({
     name: type('string').optional(),
     status: PermissionStatusSchema.optional(),
     description: type('string').optional(),
-}).and(UpsertMetadataPayloadPropertySchema);
+}).and(UpsertMetadataPropertyPayloadSchema);
 /**
  * Association
  */

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

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

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

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