@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

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

@@ -0,0 +1,295 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const resources_js_1 = require("./resources.js");
+(0, vitest_1.describe)('App Registration Resources', () => {
+    let mockInstance;
+    let registrationResources;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Mock MondoIdentity instance
+        mockInstance = {
+            config: {
+                host: 'https://api.example.com',
+                accessToken: 'test-token',
+            },
+            authorizer: vitest_1.vi.fn((req) => req),
+        };
+        registrationResources = new resources_js_1.RegistrationResources(mockInstance);
+    });
+    (0, vitest_1.describe)('RegistrationResources class', () => {
+        (0, vitest_1.test)('should initialize with MondoIdentity instance', () => {
+            (0, vitest_1.expect)(registrationResources).toBeInstanceOf(resources_js_1.RegistrationResources);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            (0, vitest_1.expect)(registrationResources['instance']).toBe(mockInstance);
+        });
+        (0, vitest_1.describe)('buildPath static method', () => {
+            (0, vitest_1.test)('should build path with app ID', () => {
+                const path = resources_js_1.RegistrationResources.buildPath('app_123');
+                (0, vitest_1.expect)(path).toBe('/v1/apps/app_123/registration');
+            });
+            (0, vitest_1.test)('should return existing path if ID already starts with /v1/apps', () => {
+                const existingPath = '/v1/apps/app_456/custom/path';
+                const path = resources_js_1.RegistrationResources.buildPath(existingPath);
+                (0, vitest_1.expect)(path).toBe(existingPath);
+            });
+            (0, vitest_1.test)('should handle empty ID', () => {
+                const path = resources_js_1.RegistrationResources.buildPath('');
+                (0, vitest_1.expect)(path).toBe('/v1/apps/registration');
+            });
+            (0, vitest_1.test)('should handle undefined ID', () => {
+                const path = resources_js_1.RegistrationResources.buildPath(undefined);
+                (0, vitest_1.expect)(path).toBe('/v1/apps/registration');
+            });
+            (0, vitest_1.test)('should filter out falsy values correctly', () => {
+                const path = resources_js_1.RegistrationResources.buildPath('app_789');
+                (0, vitest_1.expect)(path).toBe('/v1/apps/app_789/registration');
+            });
+            (0, vitest_1.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) {
+                    (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath(input)).toBe(expected);
+                }
+            });
+        });
+        (0, vitest_1.describe)('method signatures', () => {
+            (0, vitest_1.test)('should have getItem method', () => {
+                (0, vitest_1.expect)(typeof registrationResources.getItem).toBe('function');
+                (0, vitest_1.expect)(registrationResources.getItem.length).toBe(1); // id parameter
+            });
+            (0, vitest_1.test)('should have upsertItem method', () => {
+                (0, vitest_1.expect)(typeof registrationResources.upsertItem).toBe('function');
+                (0, vitest_1.expect)(registrationResources.upsertItem.length).toBe(2); // id and item parameters
+            });
+        });
+    });
+    (0, vitest_1.describe)('PATH integration', () => {
+        (0, vitest_1.test)('should use correct base PATH from parent resources', async () => {
+            const { PATH } = await Promise.resolve().then(() => __importStar(require('../resources.js')));
+            (0, vitest_1.expect)(PATH).toBe('/v1/apps');
+            // Verify the registration path builds from the base PATH
+            const appId = 'app_test';
+            const registrationPath = resources_js_1.RegistrationResources.buildPath(appId);
+            (0, vitest_1.expect)(registrationPath).toBe(`${PATH}/${appId}/registration`);
+        });
+    });
+    (0, vitest_1.describe)('RESOURCE constant', () => {
+        (0, vitest_1.test)('should construct paths with registration resource', () => {
+            const appId = 'app_example';
+            const path = resources_js_1.RegistrationResources.buildPath(appId);
+            (0, vitest_1.expect)(path).toContain('/registration');
+            (0, vitest_1.expect)(path.endsWith('/registration')).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('URL building scenarios', () => {
+        (0, vitest_1.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 = resources_js_1.RegistrationResources.buildPath(appId);
+                (0, vitest_1.expect)(result).toBe(expected);
+                (0, vitest_1.expect)(result).toMatch(/^\/v1\/apps\/.*\/registration$/);
+            }
+        });
+        (0, vitest_1.test)('should handle edge cases in path building', () => {
+            // Test with already formatted paths
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath('/v1/apps/already/formatted')).toBe('/v1/apps/already/formatted');
+            // Test with empty string
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath('')).toBe('/v1/apps/registration');
+            // Test with null/undefined
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath(null)).toBe('/v1/apps/registration');
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath(undefined)).toBe('/v1/apps/registration');
+        });
+        (0, vitest_1.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 = resources_js_1.RegistrationResources.buildPath(appId);
+                (0, vitest_1.expect)(path).toBe(`/v1/apps/${appId}/registration`);
+                (0, vitest_1.expect)(path).toMatch(/^\/v1\/apps\/app_.*\/registration$/);
+            }
+        });
+    });
+    (0, vitest_1.describe)('Integration with MondoIdentity instance', () => {
+        (0, vitest_1.test)('should store MondoIdentity instance internally', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = registrationResources['instance'];
+            (0, vitest_1.expect)(internalInstance).toBe(mockInstance);
+            (0, vitest_1.expect)(internalInstance.config.host).toBe('https://api.example.com');
+            (0, vitest_1.expect)(internalInstance.config.accessToken).toBe('test-token');
+        });
+        (0, vitest_1.test)('should maintain reference to authorizer function', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = registrationResources['instance'];
+            (0, vitest_1.expect)(typeof internalInstance.authorizer).toBe('function');
+            (0, vitest_1.expect)(internalInstance.authorizer).toBe(mockInstance.authorizer);
+        });
+        (0, vitest_1.test)('should work with different MondoIdentity configurations', () => {
+            const customInstance = {
+                config: {
+                    host: 'https://custom-registration.api.com',
+                    accessToken: 'custom-registration-token',
+                },
+                authorizer: vitest_1.vi.fn(),
+            };
+            const customResources = new resources_js_1.RegistrationResources(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            (0, vitest_1.expect)(customResources['instance']).toBe(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            (0, vitest_1.expect)(customResources['instance'].config.host).toBe('https://custom-registration.api.com');
+        });
+    });
+    (0, vitest_1.describe)('Class structure and inheritance', () => {
+        (0, vitest_1.test)('should have proper class structure', () => {
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources).toBeDefined();
+            (0, vitest_1.expect)(typeof resources_js_1.RegistrationResources).toBe('function');
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.prototype.constructor).toBe(resources_js_1.RegistrationResources);
+        });
+        (0, vitest_1.test)('should have static buildPath method', () => {
+            (0, vitest_1.expect)(typeof resources_js_1.RegistrationResources.buildPath).toBe('function');
+            (0, vitest_1.expect)(resources_js_1.RegistrationResources.buildPath).toBeDefined();
+        });
+        (0, vitest_1.test)('should have instance methods for registration operations', () => {
+            const methods = [
+                'getItem',
+                'upsertItem',
+            ];
+            for (const methodName of methods) {
+                (0, vitest_1.expect)(typeof registrationResources[methodName]).toBe('function');
+                (0, vitest_1.expect)(registrationResources[methodName]).toBeDefined();
+            }
+        });
+        (0, vitest_1.test)('should maintain method binding', () => {
+            const { getItem, upsertItem } = registrationResources;
+            (0, vitest_1.expect)(typeof getItem).toBe('function');
+            (0, vitest_1.expect)(typeof upsertItem).toBe('function');
+        });
+    });
+    (0, vitest_1.describe)('Registration operation method signatures', () => {
+        (0, vitest_1.test)('should have correct parameter counts for each method', () => {
+            // getItem(id: string)
+            (0, vitest_1.expect)(registrationResources.getItem.length).toBe(1);
+            // upsertItem(id: string, item: UpsertRegistrationInput)
+            (0, vitest_1.expect)(registrationResources.upsertItem.length).toBe(2);
+        });
+        (0, vitest_1.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
+            (0, vitest_1.expect)(registrationResources).toHaveProperty(registrationMethods.read);
+            // Upsert operation (create or update)
+            (0, vitest_1.expect)(registrationResources).toHaveProperty(registrationMethods.upsert);
+        });
+    });
+    (0, vitest_1.describe)('Path construction behavior', () => {
+        (0, vitest_1.test)('should properly filter out falsy values in path construction', () => {
+            const falsyValues = [null, undefined, ''];
+            for (const value of falsyValues) {
+                const path = resources_js_1.RegistrationResources.buildPath(value);
+                (0, vitest_1.expect)(path).toBe('/v1/apps/registration');
+            }
+        });
+        (0, vitest_1.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 = resources_js_1.RegistrationResources.buildPath(id);
+                (0, vitest_1.expect)(path).toBe(`/v1/apps/${id}/registration`);
+            }
+        });
+        (0, vitest_1.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 = resources_js_1.RegistrationResources.buildPath(id);
+                // Should start with /v1/apps
+                (0, vitest_1.expect)(path.startsWith('/v1/apps/')).toBe(true);
+                // Should end with /registration
+                (0, vitest_1.expect)(path.endsWith('/registration')).toBe(true);
+                // Should contain the app ID
+                (0, vitest_1.expect)(path).toContain(id);
+                // Should match the expected format
+                (0, vitest_1.expect)(path).toBe(`/v1/apps/${id}/registration`);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const RegistrationSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    updatedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    deletedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    deactivatedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    allowSelfRegistration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RegistrationProperties = z.input<typeof RegistrationSchema>;
+export type Registration = z.output<typeof RegistrationSchema>;
+export declare const RegistrationPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    updatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    allowSelfRegistration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RegistrationPayload = z.output<typeof RegistrationPayloadSchema>;
+export declare const UpsertRegistrationPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    allowSelfRegistration: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodUndefined]>>;
+}, z.core.$strip>;
+export type UpsertRegistrationInput = z.input<typeof UpsertRegistrationPayloadSchema>;
+export type UpsertRegistrationPayload = z.output<typeof UpsertRegistrationPayloadSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/cjs/app/registration/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,yBAAyB;;;;;;iBAMpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B;;;iBAK1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,+BAA+B,CACvC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC"}

package/dist/cjs/app/registration/schema.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsertRegistrationPayloadSchema = exports.RegistrationPayloadSchema = exports.RegistrationSchema = void 0;
+const zod_1 = require("zod");
+const dates_js_1 = require("../../common/schema/dates.js");
+const metadata_js_1 = require("../../common/schema/metadata.js");
+const AllowSelfRegistrationSchema = zod_1.z.boolean();
+const BaseSchema = zod_1.z.object({
+    allowSelfRegistration: AllowSelfRegistrationSchema.default(false),
+});
+exports.RegistrationSchema = zod_1.z.object({
+    ...BaseSchema.shape,
+    updatedAt: dates_js_1.OptionalDateSchema.optional(),
+    deletedAt: dates_js_1.OptionalDateSchema.optional(),
+    deactivatedAt: dates_js_1.OptionalDateSchema.optional(),
+    ...metadata_js_1.MetadataMapPropertySchema.shape,
+});
+exports.RegistrationPayloadSchema = zod_1.z.object({
+    ...BaseSchema.shape,
+    updatedAt: dates_js_1.OptionalDatePayloadSchema.optional(),
+    deletedAt: dates_js_1.OptionalDatePayloadSchema.optional(),
+    deactivatedAt: dates_js_1.OptionalDatePayloadSchema.optional(),
+    ...metadata_js_1.MetadataPayloadPropertySchema.shape,
+});
+exports.UpsertRegistrationPayloadSchema = zod_1.z.object({
+    allowSelfRegistration: zod_1.z
+        .union([AllowSelfRegistrationSchema, zod_1.z.undefined()])
+        .optional(),
+    ...metadata_js_1.MetadataPayloadPropertySchema.shape,
+});

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

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

package/dist/cjs/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/cjs/app/registration/schema.test.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const schema_js_1 = require("./schema.js");
+(0, vitest_1.describe)('App Registration - Schema', () => {
+    (0, vitest_1.describe)('RegistrationSchema', () => {
+        (0, vitest_1.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 = schema_js_1.RegistrationSchema.safeParse(registration);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should accept minimal registration object', () => {
+            const registration = {
+                metadata: {},
+            };
+            const result = schema_js_1.RegistrationSchema.safeParse(registration);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+            if (result.success) {
+                // Should have default allowSelfRegistration value
+                (0, vitest_1.expect)(result.data.allowSelfRegistration).toBe(false);
+            }
+        });
+        (0, vitest_1.test)('should accept registration with allowSelfRegistration false', () => {
+            const registration = {
+                allowSelfRegistration: false,
+                metadata: {
+                    registration_flow: 'invite_only',
+                    admin_approval: true,
+                },
+            };
+            const result = schema_js_1.RegistrationSchema.safeParse(registration);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+            if (result.success) {
+                (0, vitest_1.expect)(result.data.allowSelfRegistration).toBe(false);
+            }
+        });
+        (0, vitest_1.test)('should accept registration with allowSelfRegistration true', () => {
+            const registration = {
+                allowSelfRegistration: true,
+                updatedAt: new Date(),
+                metadata: {
+                    registration_flow: 'open',
+                    email_domains: 'example.com',
+                    require_email_verification: true,
+                },
+            };
+            const result = schema_js_1.RegistrationSchema.safeParse(registration);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+            if (result.success) {
+                (0, vitest_1.expect)(result.data.allowSelfRegistration).toBe(true);
+            }
+        });
+        (0, vitest_1.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 = schema_js_1.RegistrationSchema.safeParse(registration);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('RegistrationPayloadSchema', () => {
+        (0, vitest_1.test)('should accept minimal payload', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = schema_js_1.RegistrationPayloadSchema.safeParse(payload);
+            (0, vitest_1.expect)(result.success).toBe(true);
+            (0, vitest_1.expect)(result.data?.allowSelfRegistration).toBe(false);
+        });
+        (0, vitest_1.test)('should accept payload with allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: false,
+                metadata: {
+                    admin_approval_required: true,
+                },
+            };
+            const result = schema_js_1.RegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+            if (result.success) {
+                (0, vitest_1.expect)(result.data).toEqual(payload);
+            }
+        });
+        (0, vitest_1.test)('should accept payload with optional dates', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                updatedAt: new Date().toISOString(),
+                metadata: {
+                    configured_at: new Date().toISOString(),
+                },
+            };
+            const result = schema_js_1.RegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('UpsertRegistrationPayloadSchema', () => {
+        (0, vitest_1.test)('should accept upsert with allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: true,
+                metadata: {
+                    updated_by: 'admin@example.com',
+                },
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should accept upsert without allowSelfRegistration', () => {
+            const payload = {
+                metadata: {
+                    config_version: '2.1',
+                },
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should accept upsert with undefined allowSelfRegistration', () => {
+            const payload = {
+                allowSelfRegistration: undefined,
+                metadata: {},
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should accept empty metadata', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should accept comprehensive upsert payload', () => {
+            const payload = {
+                allowSelfRegistration: false,
+                metadata: {
+                    registration_flow: 'invite_only',
+                    email_domains: 'corp.example.com',
+                    admin_approval: true,
+                    require_email_verification: true,
+                    welcome_email_enabled: false,
+                    custom_registration_fields: 'department',
+                },
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            (0, vitest_1.expect)(result.success).toBe(true);
+        });
+        (0, vitest_1.test)('should reject invalid allowSelfRegistration type', () => {
+            const payload = {
+                allowSelfRegistration: 'invalid', // should be boolean
+                metadata: {},
+            };
+            const result = schema_js_1.UpsertRegistrationPayloadSchema.safeParse(payload);
+            (0, vitest_1.expect)(result.success).toBe(false);
+        });
+    });
+});

package/dist/cjs/app/resources.d.ts

@@ -0,0 +1,21 @@
+import type { MondoIdentity } from '../common/resources/init.js';
+import { type PaginationCollection } from '../common/schema/collection.js';
+import type { Pagination } from '../common/schema/pagination.js';
+import { type App, type InsertAppInput, type UpdateAppInput } from './schema.js';
+export declare const PATH = "/v1/apps";
+export declare class AppResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(id?: string): string;
+    listItems(pagination?: Pagination): Promise<PaginationCollection<App>>;
+    getItem(id: string): Promise<App>;
+    insertItem(item: InsertAppInput): Promise<App>;
+    updateItem(id: string, item: UpdateAppInput): Promise<App>;
+    deleteItem(id: string): Promise<App>;
+}
+export declare function listApps(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<App>>;
+export declare function getApp(instance: MondoIdentity, id: string): Promise<App>;
+export declare function insertApp(instance: MondoIdentity, item: InsertAppInput): Promise<App>;
+export declare function updateApp(instance: MondoIdentity, id: string, item: UpdateAppInput): Promise<App>;
+export declare function deleteApp(instance: MondoIdentity, id: string): Promise<App>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/cjs/app/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/app/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAQjE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EACL,KAAK,GAAG,EAER,KAAK,cAAc,EAEnB,KAAK,cAAc,EAEpB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,IAAI,aAAa,CAAC;AAE/B,qBAAa,YAAY;IACJ,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAQ9B,SAAS,CACd,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IAI9B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAIjC,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAI9C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAI1D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;CAG5C;AAED,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CASpC;AAED,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,GAAG,CAAC,CAOd;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,GAAG,CAAC,CAQd;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,GAAG,CAAC,CAQd;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,GAAG,CAAC,CAOd"}

package/dist/cjs/app/resources.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppResources = exports.PATH = void 0;
+exports.listApps = listApps;
+exports.getApp = getApp;
+exports.insertApp = insertApp;
+exports.updateApp = updateApp;
+exports.deleteApp = deleteApp;
+const operations_js_1 = require("../common/resources/operations.js");
+const utils_js_1 = require("../common/resources/utils.js");
+const collection_js_1 = require("../common/schema/collection.js");
+const schema_js_1 = require("./schema.js");
+exports.PATH = '/v1/apps';
+class AppResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(id) {
+        if (id?.startsWith(exports.PATH)) {
+            return id;
+        }
+        return [exports.PATH, id].filter(Boolean).join('/');
+    }
+    listItems(pagination) {
+        return listApps(this.instance, pagination);
+    }
+    getItem(id) {
+        return getApp(this.instance, id);
+    }
+    insertItem(item) {
+        return insertApp(this.instance, item);
+    }
+    updateItem(id, item) {
+        return updateApp(this.instance, id, item);
+    }
+    deleteItem(id) {
+        return deleteApp(this.instance, id);
+    }
+}
+exports.AppResources = AppResources;
+async function listApps(instance, pagination) {
+    const url = (0, utils_js_1.addPaginationToURL)(new URL(AppResources.buildPath(), instance.config.host), pagination);
+    return (0, collection_js_1.PaginationCollectionSchema)(schema_js_1.AppSchema).parse(await (0, operations_js_1.getItemWithAuthorization)(url, instance.authorizer));
+}
+async function getApp(instance, id) {
+    return schema_js_1.AppSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer));
+}
+async function insertApp(instance, item) {
+    return schema_js_1.AppSchema.parse(await (0, operations_js_1.insertItemWithAuthorization)(new URL(AppResources.buildPath(), instance.config.host), instance.authorizer, schema_js_1.InsertAppPayloadSchema.parse));
+}
+async function updateApp(instance, id, item) {
+    return schema_js_1.AppSchema.parse(await (0, operations_js_1.updateItemWithAuthorization)(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer, schema_js_1.UpdateAppPayloadSchema.parse(item)));
+}
+async function deleteApp(instance, id) {
+    return schema_js_1.AppSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(AppResources.buildPath(id), instance.config.host), instance.authorizer));
+}

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

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

package/dist/cjs/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":""}