@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

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.d.ts

@@ -0,0 +1,17 @@
+export type HttpErrorOptions = {
+    statusCode?: number;
+    type?: string;
+    trace?: string;
+    body?: {
+        [key: string]: string;
+    };
+};
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly type: string;
+    readonly trace?: HttpErrorOptions['trace'];
+    readonly body?: HttpErrorOptions['body'];
+    constructor(message?: string, options?: HttpErrorOptions);
+    get isAuthorizationError(): boolean;
+}
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/http.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QACL,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;gBAGvC,OAAO,SAA+D,EACtE,OAAO,CAAC,EAAE,gBAAgB;IAQ5B,IAAI,oBAAoB,IAAI,OAAO,CAElC;CACF"}

package/dist/esm/common/errors/http.js

@@ -0,0 +1,14 @@
+export class HttpError extends Error {
+    statusCode;
+    type;
+    trace;
+    body;
+    constructor(message = 'An unknown error occurred. Please try the operation again.', options) {
+        super(message);
+        this.statusCode = options?.statusCode || 500;
+        this.type = options?.type || 'Unknown';
+    }
+    get isAuthorizationError() {
+        return [401, 403].includes(this.statusCode);
+    }
+}

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":""}

package/dist/esm/common/errors/http.test.js

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'vitest';
+import { HttpError } from './http.js';
+describe('Common Errors - HTTP', () => {
+    describe('HttpError', () => {
+        test('should create error with default message and status', () => {
+            const error = new HttpError();
+            expect(error.message).toBe('An unknown error occurred. Please try the operation again.');
+            expect(error.statusCode).toBe(500);
+            expect(error.type).toBe('Unknown');
+            expect(error.trace).toBeUndefined();
+            expect(error.body).toBeUndefined();
+        });
+        test('should create error with custom message', () => {
+            const error = new HttpError('Custom error message');
+            expect(error.message).toBe('Custom error message');
+            expect(error.statusCode).toBe(500);
+            expect(error.type).toBe('Unknown');
+        });
+        test('should create error with custom options', () => {
+            const options = {
+                statusCode: 404,
+                type: 'NotFound',
+                trace: 'trace-123',
+                body: { resource: 'user' },
+            };
+            const error = new HttpError('Resource not found', options);
+            expect(error.message).toBe('Resource not found');
+            expect(error.statusCode).toBe(404);
+            expect(error.type).toBe('NotFound');
+            expect(error.trace).toBeUndefined(); // trace is not assigned in constructor
+            expect(error.body).toBeUndefined(); // body is not assigned in constructor
+        });
+        test('should handle partial options', () => {
+            const error = new HttpError('Test error', { statusCode: 400 });
+            expect(error.message).toBe('Test error');
+            expect(error.statusCode).toBe(400);
+            expect(error.type).toBe('Unknown');
+            expect(error.trace).toBeUndefined();
+            expect(error.body).toBeUndefined();
+        });
+        test('should be instance of Error', () => {
+            const error = new HttpError();
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(HttpError);
+        });
+        describe('isAuthorizationError', () => {
+            test('should return true for 401 status', () => {
+                const error = new HttpError('Unauthorized', { statusCode: 401 });
+                expect(error.isAuthorizationError).toBe(true);
+            });
+            test('should return true for 403 status', () => {
+                const error = new HttpError('Forbidden', { statusCode: 403 });
+                expect(error.isAuthorizationError).toBe(true);
+            });
+            test('should return false for other status codes', () => {
+                const error400 = new HttpError('Bad Request', { statusCode: 400 });
+                const error404 = new HttpError('Not Found', { statusCode: 404 });
+                const error500 = new HttpError('Internal Error', { statusCode: 500 });
+                expect(error400.isAuthorizationError).toBe(false);
+                expect(error404.isAuthorizationError).toBe(false);
+                expect(error500.isAuthorizationError).toBe(false);
+            });
+            test('should return false for default status code', () => {
+                const error = new HttpError();
+                expect(error.isAuthorizationError).toBe(false);
+            });
+        });
+    });
+});

package/dist/esm/common/errors/validation.d.ts

@@ -0,0 +1,11 @@
+import { HttpError, type HttpErrorOptions } from './http.js';
+export type ValidationErrorOptions = HttpErrorOptions & {
+    fields: {
+        [key: string]: string;
+    };
+};
+export declare class ValidationError extends HttpError {
+    readonly fields: ValidationErrorOptions['fields'];
+    constructor(message: string, options: ValidationErrorOptions);
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/esm/common/errors/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG;IACtD,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,CAAC;gBAE/B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;CAIpE"}

package/dist/esm/common/errors/validation.js

@@ -0,0 +1,8 @@
+import { HttpError } from './http.js';
+export class ValidationError extends HttpError {
+    fields;
+    constructor(message, options) {
+        super(message, options);
+        this.fields = options?.fields;
+    }
+}

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

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

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

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

package/dist/esm/common/errors/validation.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, test } from 'vitest';
+import { HttpError } from './http.js';
+import { ValidationError } from './validation.js';
+describe('Common Errors - Validation', () => {
+    describe('ValidationError', () => {
+        test('should create validation error with fields', () => {
+            const fields = {
+                email: 'Invalid email format',
+                name: 'Name is required',
+            };
+            const options = {
+                statusCode: 400,
+                type: 'ValidationError',
+                fields,
+            };
+            const error = new ValidationError('Validation failed', options);
+            expect(error.message).toBe('Validation failed');
+            expect(error.statusCode).toBe(400);
+            expect(error.type).toBe('ValidationError');
+            expect(error.fields).toEqual(fields);
+        });
+        test('should inherit from HttpError', () => {
+            const fields = { field: 'error' };
+            const error = new ValidationError('Test', { fields });
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(HttpError);
+            expect(error).toBeInstanceOf(ValidationError);
+        });
+        test('should use default HTTP error properties when not specified', () => {
+            const fields = { field: 'error' };
+            const error = new ValidationError('Test validation error', { fields });
+            expect(error.message).toBe('Test validation error');
+            expect(error.statusCode).toBe(500); // HttpError default
+            expect(error.type).toBe('Unknown'); // HttpError default
+            expect(error.fields).toEqual(fields);
+        });
+        test('should handle all HttpError options plus fields', () => {
+            const options = {
+                statusCode: 422,
+                type: 'UnprocessableEntity',
+                trace: 'validation-trace-456',
+                body: { request: 'data' },
+                fields: { username: 'Username already exists' },
+            };
+            const error = new ValidationError('Unprocessable entity', options);
+            expect(error.message).toBe('Unprocessable entity');
+            expect(error.statusCode).toBe(422);
+            expect(error.type).toBe('UnprocessableEntity');
+            expect(error.trace).toBeUndefined(); // trace is not assigned in HttpError constructor
+            expect(error.body).toBeUndefined(); // body is not assigned in HttpError constructor
+            expect(error.fields).toEqual({ username: 'Username already exists' });
+        });
+        test('should inherit isAuthorizationError from HttpError', () => {
+            const fields = { field: 'error' };
+            const error401 = new ValidationError('Unauthorized', {
+                statusCode: 401,
+                fields,
+            });
+            const error403 = new ValidationError('Forbidden', {
+                statusCode: 403,
+                fields,
+            });
+            const error400 = new ValidationError('Bad Request', {
+                statusCode: 400,
+                fields,
+            });
+            expect(error401.isAuthorizationError).toBe(true);
+            expect(error403.isAuthorizationError).toBe(true);
+            expect(error400.isAuthorizationError).toBe(false);
+        });
+        test('should handle empty fields object', () => {
+            const error = new ValidationError('No field errors', { fields: {} });
+            expect(error.fields).toEqual({});
+            expect(error.message).toBe('No field errors');
+        });
+        test('should handle multiple field errors', () => {
+            const fields = {
+                email: 'Email is invalid',
+                password: 'Password too short',
+                confirmPassword: 'Passwords do not match',
+                age: 'Must be 18 or older',
+            };
+            const error = new ValidationError('Multiple validation errors', {
+                fields,
+            });
+            expect(error.fields).toEqual(fields);
+            expect(Object.keys(error.fields)).toHaveLength(4);
+        });
+    });
+});

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

@@ -0,0 +1,7 @@
+import { MondoIdentity } from './resources/init.js';
+export { defaultMutationRequestHeaders, defaultRequestHeaders, responseToHttpError, toHttpError, } from './resources/utils.js';
+export * from './errors/http.js';
+export * from './errors/validation.js';
+export * from './schema/schema.js';
+export default MondoIdentity;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EACL,6BAA6B,EAC7B,qBAAqB,EACrB,mBAAmB,EACnB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAE9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,oBAAoB,CAAC;AAEnC,eAAe,aAAa,CAAC"}

package/dist/esm/common/index.js

@@ -0,0 +1,6 @@
+import { MondoIdentity } from './resources/init.js';
+export { defaultMutationRequestHeaders, defaultRequestHeaders, responseToHttpError, toHttpError, } from './resources/utils.js';
+export * from './errors/http.js';
+export * from './errors/validation.js';
+export * from './schema/schema.js';
+export default MondoIdentity;

package/dist/esm/common/resources/authorization.d.ts

@@ -0,0 +1,2 @@
+export type Authorization = (request: RequestInit) => RequestInit;
+//# sourceMappingURL=authorization.d.ts.map

package/dist/esm/common/resources/authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/authorization.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,WAAW,CAAC"}

package/dist/esm/common/resources/authorization.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/common/resources/init.d.ts

@@ -0,0 +1,16 @@
+declare const ConfigSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    host: (In: import("arktype/internal/attributes.ts").Default<string, "https://manage-api.mondoidentity.com">) => import("arktype/internal/attributes.ts").To<URL>;
+    accessToken: string;
+}, {}>;
+export type ConfigProps = typeof ConfigSchema.inferIn;
+export type Config = typeof ConfigSchema.inferOut;
+export declare class MondoIdentity {
+    readonly config: Config;
+    constructor(config: ConfigProps);
+    /**
+     * Builds an authorizer function based on the type of access token
+     */
+    get authorizer(): (request: RequestInit) => RequestInit;
+}
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/esm/common/resources/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/common/resources/init.ts"],"names":[],"mappings":"AAYA,QAAA,MAAM,YAAY;;;MAA0B,CAAC;AAE7C,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,OAAO,CAAC;AACtD,MAAM,MAAM,MAAM,GAAG,OAAO,YAAY,CAAC,QAAQ,CAAC;AAElD,qBAAa,aAAa;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEL,MAAM,EAAE,WAAW;IAItC;;OAEG;IACH,IAAW,UAAU,IAAI,CAAC,OAAO,EAAE,WAAW,KAAK,WAAW,CAU7D;CAuBF"}

package/dist/esm/common/resources/init.js

@@ -0,0 +1,34 @@
+import { type } from 'arktype';
+const BaseConfigSchema = type({
+    host: type('string.url.parse').default('https://manage-api.mondoidentity.com'),
+});
+const AccessTokenConfigSchema = BaseConfigSchema.and({
+    accessToken: type('string').moreThanLength(0),
+});
+const ConfigSchema = AccessTokenConfigSchema;
+export class MondoIdentity {
+    config;
+    constructor(config) {
+        this.config = initConfig(config);
+    }
+    /**
+     * Builds an authorizer function based on the type of access token
+     */
+    get authorizer() {
+        if (this.config.accessToken) {
+            return (request) => {
+                request.headers = new Headers(request.headers);
+                request.headers.append('authorization', this.config.accessToken);
+                return request;
+            };
+        }
+        return (request) => request;
+    }
+}
+function initConfig(config) {
+    const out = ConfigSchema(config);
+    if (out instanceof type.errors) {
+        throw new Error(`Invalid configuration: ${out.summary}`);
+    }
+    return out;
+}