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

package/dist/esm/app/oidc/schema.test.js

@@ -0,0 +1,93 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { InsertOIDCPayloadSchema, OIDCPayloadSchema, OIDCSchema, UpdateOIDCPayloadSchema, } from './schema.js';
+describe('App OIDC - Schema', () => {
+    describe('OIDCSchema', () => {
+        test('should accept complete OIDC object', () => {
+            const oidc = {
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: { provider: 'auth0' },
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal OIDC object', () => {
+            const oidc = {
+                metadata: {},
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept OIDC with only some optional dates', () => {
+            const oidc = {
+                updatedAt: new Date(),
+                metadata: { configured: true },
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('OIDCPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: { issuer: 'https://auth.example.com' },
+            };
+            const result = OIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal payload', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = OIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                updatedAt: new Date().toISOString(),
+                metadata: { clientId: 'oidc_client_123' },
+            };
+            const result = OIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertOIDCPayloadSchema', () => {
+        test('should accept metadata payload', () => {
+            const payload = {
+                metadata: { setup: 'initial' },
+            };
+            const result = InsertOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept undefined', () => {
+            const result = InsertOIDCPayloadSchema(undefined);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeUndefined();
+        });
+        test('should accept empty metadata', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = InsertOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateOIDCPayloadSchema', () => {
+        test('should accept metadata update', () => {
+            const payload = {
+                metadata: { version: '2.0' },
+            };
+            const result = UpdateOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+    });
+});

package/dist/esm/app/registration/resources.test.d.ts

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

package/dist/esm/app/registration/resources.test.d.ts.map

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

package/dist/esm/app/registration/resources.test.js

@@ -0,0 +1,260 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { RegistrationResources } from './resources.js';
+describe('App Registration Resources', () => {
+    let mockInstance;
+    let registrationResources;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock MondoIdentity instance
+        mockInstance = {
+            config: {
+                host: 'https://api.example.com',
+                accessToken: 'test-token',
+            },
+            authorizer: vi.fn((req) => req),
+        };
+        registrationResources = new RegistrationResources(mockInstance);
+    });
+    describe('RegistrationResources class', () => {
+        test('should initialize with MondoIdentity instance', () => {
+            expect(registrationResources).toBeInstanceOf(RegistrationResources);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(registrationResources['instance']).toBe(mockInstance);
+        });
+        describe('buildPath static method', () => {
+            test('should build path with app ID', () => {
+                const path = RegistrationResources.buildPath('app_123');
+                expect(path).toBe('/v1/apps/app_123/registration');
+            });
+            test('should return existing path if ID already starts with /v1/apps', () => {
+                const existingPath = '/v1/apps/app_456/custom/path';
+                const path = RegistrationResources.buildPath(existingPath);
+                expect(path).toBe(existingPath);
+            });
+            test('should handle empty ID', () => {
+                const path = RegistrationResources.buildPath('');
+                expect(path).toBe('/v1/apps/registration');
+            });
+            test('should handle undefined ID', () => {
+                const path = RegistrationResources.buildPath(undefined);
+                expect(path).toBe('/v1/apps/registration');
+            });
+            test('should filter out falsy values correctly', () => {
+                const path = RegistrationResources.buildPath('app_789');
+                expect(path).toBe('/v1/apps/app_789/registration');
+            });
+            test('should handle various app ID patterns', () => {
+                const testCases = [
+                    { input: 'app_12345', expected: '/v1/apps/app_12345/registration' },
+                    {
+                        input: 'app_production',
+                        expected: '/v1/apps/app_production/registration',
+                    },
+                    {
+                        input: 'app_test_env',
+                        expected: '/v1/apps/app_test_env/registration',
+                    },
+                    { input: '/v1/apps/existing', expected: '/v1/apps/existing' },
+                    { input: '/v1/apps/nested/path', expected: '/v1/apps/nested/path' },
+                ];
+                for (const { input, expected } of testCases) {
+                    expect(RegistrationResources.buildPath(input)).toBe(expected);
+                }
+            });
+        });
+        describe('method signatures', () => {
+            test('should have getItem method', () => {
+                expect(typeof registrationResources.getItem).toBe('function');
+                expect(registrationResources.getItem.length).toBe(1); // id parameter
+            });
+            test('should have upsertItem method', () => {
+                expect(typeof registrationResources.upsertItem).toBe('function');
+                expect(registrationResources.upsertItem.length).toBe(2); // id and item parameters
+            });
+        });
+    });
+    describe('PATH integration', () => {
+        test('should use correct base PATH from parent resources', async () => {
+            const { PATH } = await import('../resources.js');
+            expect(PATH).toBe('/v1/apps');
+            // Verify the registration path builds from the base PATH
+            const appId = 'app_test';
+            const registrationPath = RegistrationResources.buildPath(appId);
+            expect(registrationPath).toBe(`${PATH}/${appId}/registration`);
+        });
+    });
+    describe('RESOURCE constant', () => {
+        test('should construct paths with registration resource', () => {
+            const appId = 'app_example';
+            const path = RegistrationResources.buildPath(appId);
+            expect(path).toContain('/registration');
+            expect(path.endsWith('/registration')).toBe(true);
+        });
+    });
+    describe('URL building scenarios', () => {
+        test('should create proper URL structure for different app types', () => {
+            const scenarios = [
+                {
+                    appId: 'app_web_frontend',
+                    expected: '/v1/apps/app_web_frontend/registration',
+                },
+                {
+                    appId: 'app_mobile_ios',
+                    expected: '/v1/apps/app_mobile_ios/registration',
+                },
+                {
+                    appId: 'app_api_gateway',
+                    expected: '/v1/apps/app_api_gateway/registration',
+                },
+                {
+                    appId: 'app_enterprise_sso',
+                    expected: '/v1/apps/app_enterprise_sso/registration',
+                },
+            ];
+            for (const { appId, expected } of scenarios) {
+                const result = RegistrationResources.buildPath(appId);
+                expect(result).toBe(expected);
+                expect(result).toMatch(/^\/v1\/apps\/.*\/registration$/);
+            }
+        });
+        test('should handle edge cases in path building', () => {
+            // Test with already formatted paths
+            expect(RegistrationResources.buildPath('/v1/apps/already/formatted')).toBe('/v1/apps/already/formatted');
+            // Test with empty string
+            expect(RegistrationResources.buildPath('')).toBe('/v1/apps/registration');
+            // Test with null/undefined
+            expect(RegistrationResources.buildPath(null)).toBe('/v1/apps/registration');
+            expect(RegistrationResources.buildPath(undefined)).toBe('/v1/apps/registration');
+        });
+        test('should create valid URL paths for various app patterns', () => {
+            const appPatterns = [
+                'app_development_env',
+                'app_staging_v2',
+                'app_production_main',
+                'app_testing_sandbox',
+                'app_demo_instance',
+            ];
+            for (const appId of appPatterns) {
+                const path = RegistrationResources.buildPath(appId);
+                expect(path).toBe(`/v1/apps/${appId}/registration`);
+                expect(path).toMatch(/^\/v1\/apps\/app_.*\/registration$/);
+            }
+        });
+    });
+    describe('Integration with MondoIdentity instance', () => {
+        test('should store MondoIdentity instance internally', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = registrationResources['instance'];
+            expect(internalInstance).toBe(mockInstance);
+            expect(internalInstance.config.host).toBe('https://api.example.com');
+            expect(internalInstance.config.accessToken).toBe('test-token');
+        });
+        test('should maintain reference to authorizer function', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = registrationResources['instance'];
+            expect(typeof internalInstance.authorizer).toBe('function');
+            expect(internalInstance.authorizer).toBe(mockInstance.authorizer);
+        });
+        test('should work with different MondoIdentity configurations', () => {
+            const customInstance = {
+                config: {
+                    host: 'https://custom-registration.api.com',
+                    accessToken: 'custom-registration-token',
+                },
+                authorizer: vi.fn(),
+            };
+            const customResources = new RegistrationResources(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance']).toBe(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance'].config.host).toBe('https://custom-registration.api.com');
+        });
+    });
+    describe('Class structure and inheritance', () => {
+        test('should have proper class structure', () => {
+            expect(RegistrationResources).toBeDefined();
+            expect(typeof RegistrationResources).toBe('function');
+            expect(RegistrationResources.prototype.constructor).toBe(RegistrationResources);
+        });
+        test('should have static buildPath method', () => {
+            expect(typeof RegistrationResources.buildPath).toBe('function');
+            expect(RegistrationResources.buildPath).toBeDefined();
+        });
+        test('should have instance methods for registration operations', () => {
+            const methods = [
+                'getItem',
+                'upsertItem',
+            ];
+            for (const methodName of methods) {
+                expect(typeof registrationResources[methodName]).toBe('function');
+                expect(registrationResources[methodName]).toBeDefined();
+            }
+        });
+        test('should maintain method binding', () => {
+            const { getItem, upsertItem } = registrationResources;
+            expect(typeof getItem).toBe('function');
+            expect(typeof upsertItem).toBe('function');
+        });
+    });
+    describe('Registration operation method signatures', () => {
+        test('should have correct parameter counts for each method', () => {
+            // getItem(id: string)
+            expect(registrationResources.getItem.length).toBe(1);
+            // upsertItem(id: string, item: UpsertRegistrationInput)
+            expect(registrationResources.upsertItem.length).toBe(2);
+        });
+        test('should support registration-specific workflow pattern', () => {
+            // This test verifies the class provides the expected registration interface
+            // without actually calling the methods (which would require complex mocking)
+            const registrationMethods = {
+                read: 'getItem',
+                upsert: 'upsertItem',
+            };
+            // Read operation
+            expect(registrationResources).toHaveProperty(registrationMethods.read);
+            // Upsert operation (create or update)
+            expect(registrationResources).toHaveProperty(registrationMethods.upsert);
+        });
+    });
+    describe('Path construction behavior', () => {
+        test('should properly filter out falsy values in path construction', () => {
+            const falsyValues = [null, undefined, ''];
+            for (const value of falsyValues) {
+                const path = RegistrationResources.buildPath(value);
+                expect(path).toBe('/v1/apps/registration');
+            }
+        });
+        test('should handle complex app ID formats', () => {
+            const complexIds = [
+                'app_complex-name_123',
+                'app_with.dots',
+                'app_with_multiple_underscores',
+                'app-with-dashes',
+                'app123numbers',
+            ];
+            for (const id of complexIds) {
+                const path = RegistrationResources.buildPath(id);
+                expect(path).toBe(`/v1/apps/${id}/registration`);
+            }
+        });
+        test('should maintain consistent path structure', () => {
+            const testIds = [
+                'app_simple',
+                'app_complex_id_with_many_parts',
+                'app_short',
+                'app_with_numbers_123_456',
+            ];
+            for (const id of testIds) {
+                const path = RegistrationResources.buildPath(id);
+                // Should start with /v1/apps
+                expect(path.startsWith('/v1/apps/')).toBe(true);
+                // Should end with /registration
+                expect(path.endsWith('/registration')).toBe(true);
+                // Should contain the app ID
+                expect(path).toContain(id);
+                // Should match the expected format
+                expect(path).toBe(`/v1/apps/${id}/registration`);
+            }
+        });
+    });
+});

package/dist/esm/app/registration/schema.d.ts

@@ -3,7 +3,7 @@ export declare const RegistrationSchema: import("arktype/internal/methods/object
     updatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | 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 RegistrationProperties = typeof RegistrationSchema.inferIn;
 export type Registration = typeof RegistrationSchema.inferOut;

package/dist/esm/app/registration/schema.test.d.ts

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

package/dist/esm/app/registration/schema.test.d.ts.map

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

package/dist/esm/app/registration/schema.test.js

@@ -0,0 +1,260 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { RegistrationPayloadSchema, RegistrationSchema, UpsertRegistrationPayloadSchema, } from './schema.js';
+describe('App Registration - Schema', () => {
+    describe('RegistrationSchema', () => {
+        test('should accept complete registration object', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {
+                    approval_required: false,
+                    email_verification: true,
+                    default_role: 'user',
+                },
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal registration object', () => {
+            const registration = {
+                metadata: {},
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Should have default allowSelfRegistration value
+            expect(result.allowSelfRegistration).toBe(false);
+        });
+        test('should accept registration with allowSelfRegistration false', () => {
+            const registration = {
+                allowSelfRegistration: false,
+                metadata: {
+                    registration_flow: 'invite_only',
+                    admin_approval: true,
+                },
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.allowSelfRegistration).toBe(false);
+        });
+        test('should accept registration with allowSelfRegistration true', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: new Date(),
+                metadata: {
+                    registration_flow: 'open',
+                    email_domains: ['example.com', 'company.org'],
+                    require_email_verification: true,
+                },
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.allowSelfRegistration).toBe(true);
+        });
+        test('should accept registration with optional dates', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: new Date(),
+                metadata: {
+                    last_config_change: new Date().toISOString(),
+                    configured_by: 'admin@example.com',
+                },
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept registration with complex metadata', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                metadata: {
+                    settings: {
+                        email_verification_required: true,
+                        phone_verification_required: false,
+                        captcha_required: true,
+                        password_policy: {
+                            min_length: 8,
+                            require_uppercase: true,
+                            require_lowercase: true,
+                            require_numbers: true,
+                            require_symbols: false,
+                        },
+                    },
+                    restrictions: {
+                        allowed_domains: ['company.com', 'partner.org'],
+                        blocked_domains: ['tempmail.com', 'guerrillamail.info'],
+                        max_registrations_per_day: 100,
+                        rate_limit_per_ip: 5,
+                    },
+                    workflow: {
+                        approval_workflow: false,
+                        auto_assign_role: 'member',
+                        welcome_email: true,
+                        onboarding_flow: 'standard',
+                    },
+                },
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid allowSelfRegistration type', () => {
+            const registration = {
+                allowSelfRegistration: 'yes', // should be boolean
+                metadata: {},
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid date types', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: 'invalid-date',
+                metadata: {},
+            };
+            const result = RegistrationSchema(registration);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('RegistrationPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {
+                    configuration: 'open_registration',
+                    updated_by: 'admin@example.com',
+                },
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal payload', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.allowSelfRegistration).toBe(false);
+        });
+        test('should accept payload with allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                metadata: {
+                    feature_enabled: true,
+                    enabled_at: new Date().toISOString(),
+                },
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                allowSelfRegistration: false,
+                updatedAt: new Date().toISOString(),
+                metadata: {
+                    disabled_reason: 'maintenance',
+                    re_enable_at: new Date().toISOString(),
+                },
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept payload with comprehensive registration settings', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                updatedAt: new Date().toISOString(),
+                metadata: {
+                    email_format: 'strict',
+                    name_min_length: 2,
+                    phone_format: 'international',
+                },
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid date format', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                updatedAt: 'invalid-date',
+                metadata: {},
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid allowSelfRegistration type', () => {
+            const payload = {
+                allowSelfRegistration: 'true', // should be boolean
+                metadata: {},
+            };
+            const result = RegistrationPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpsertRegistrationPayloadSchema', () => {
+        test('should accept upsert with allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                metadata: {
+                    operation: 'enable_self_registration',
+                    reason: 'open_beta_launch',
+                },
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept upsert without allowSelfRegistration', () => {
+            const payload = {
+                metadata: {
+                    operation: 'enable_self_registration',
+                    reason: 'open_beta_launch',
+                },
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept upsert with undefined allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: undefined,
+                metadata: {
+                    partial_update: true,
+                },
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept empty metadata', () => {
+            const payload = {
+                allowSelfRegistration: false,
+                metadata: {},
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept comprehensive upsert payload', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                metadata: {
+                    updated_by: 'admin@example.com',
+                    change_reason: 'platform_upgrade',
+                },
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid allowSelfRegistration type', () => {
+            const payload = {
+                allowSelfRegistration: 'maybe', // should be boolean or undefined
+                metadata: {},
+            };
+            const result = UpsertRegistrationPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/app/resources.test.d.ts

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

package/dist/esm/app/resources.test.d.ts.map

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