@enterprisestandard/react 0.0.5-beta.20260115.1 → 0.0.5-beta.20260115.3

package/dist/types/scim-schema.js

@@ -0,0 +1,519 @@
+/**
+ * Validates a string field
+ */
+function validateString(value, fieldName, required, issues, path) {
+    if (value === undefined || value === null) {
+        if (required) {
+            issues.push({
+                message: `${fieldName} is required`,
+                path,
+            });
+        }
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        issues.push({
+            message: `${fieldName} must be a string`,
+            path,
+        });
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Validates a boolean field
+ */
+function validateBoolean(value, fieldName, issues, path) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        issues.push({
+            message: `${fieldName} must be a boolean`,
+            path,
+        });
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Validates a SCIM Name object
+ */
+function validateName(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'object' || value === null) {
+        issues.push({
+            message: 'name must be an object',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const name = value;
+    const result = {};
+    result.formatted = validateString(name.formatted, 'formatted', false, issues, [...basePath, 'formatted']);
+    result.familyName = validateString(name.familyName, 'familyName', false, issues, [...basePath, 'familyName']);
+    result.givenName = validateString(name.givenName, 'givenName', false, issues, [...basePath, 'givenName']);
+    result.middleName = validateString(name.middleName, 'middleName', false, issues, [...basePath, 'middleName']);
+    result.honorificPrefix = validateString(name.honorificPrefix, 'honorificPrefix', false, issues, [
+        ...basePath,
+        'honorificPrefix',
+    ]);
+    result.honorificSuffix = validateString(name.honorificSuffix, 'honorificSuffix', false, issues, [
+        ...basePath,
+        'honorificSuffix',
+    ]);
+    return result;
+}
+/**
+ * Validates a SCIM Email array
+ */
+function validateEmails(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'emails must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const emails = [];
+    for (let i = 0; i < value.length; i++) {
+        const email = value[i];
+        const emailPath = [...basePath, i];
+        if (typeof email !== 'object' || email === null) {
+            issues.push({
+                message: 'email must be an object',
+                path: emailPath,
+            });
+            continue;
+        }
+        const emailObj = email;
+        const emailValue = validateString(emailObj.value, 'value', true, issues, [...emailPath, 'value']);
+        if (emailValue) {
+            emails.push({
+                value: emailValue,
+                display: validateString(emailObj.display, 'display', false, issues, [...emailPath, 'display']),
+                type: validateString(emailObj.type, 'type', false, issues, [...emailPath, 'type']),
+                primary: validateBoolean(emailObj.primary, 'primary', issues, [...emailPath, 'primary']),
+            });
+        }
+    }
+    return emails.length > 0 ? emails : undefined;
+}
+/**
+ * Validates a SCIM PhoneNumber array
+ */
+function validatePhoneNumbers(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'phoneNumbers must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const phoneNumbers = [];
+    for (let i = 0; i < value.length; i++) {
+        const phone = value[i];
+        const phonePath = [...basePath, i];
+        if (typeof phone !== 'object' || phone === null) {
+            issues.push({
+                message: 'phoneNumber must be an object',
+                path: phonePath,
+            });
+            continue;
+        }
+        const phoneObj = phone;
+        const phoneValue = validateString(phoneObj.value, 'value', true, issues, [...phonePath, 'value']);
+        if (phoneValue) {
+            phoneNumbers.push({
+                value: phoneValue,
+                display: validateString(phoneObj.display, 'display', false, issues, [...phonePath, 'display']),
+                type: validateString(phoneObj.type, 'type', false, issues, [...phonePath, 'type']),
+                primary: validateBoolean(phoneObj.primary, 'primary', issues, [...phonePath, 'primary']),
+            });
+        }
+    }
+    return phoneNumbers.length > 0 ? phoneNumbers : undefined;
+}
+/**
+ * Validates a SCIM Address array
+ */
+function validateAddresses(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'addresses must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const addresses = [];
+    for (let i = 0; i < value.length; i++) {
+        const address = value[i];
+        const addressPath = [...basePath, i];
+        if (typeof address !== 'object' || address === null) {
+            issues.push({
+                message: 'address must be an object',
+                path: addressPath,
+            });
+            continue;
+        }
+        const addressObj = address;
+        addresses.push({
+            formatted: validateString(addressObj.formatted, 'formatted', false, issues, [...addressPath, 'formatted']),
+            streetAddress: validateString(addressObj.streetAddress, 'streetAddress', false, issues, [
+                ...addressPath,
+                'streetAddress',
+            ]),
+            locality: validateString(addressObj.locality, 'locality', false, issues, [...addressPath, 'locality']),
+            region: validateString(addressObj.region, 'region', false, issues, [...addressPath, 'region']),
+            postalCode: validateString(addressObj.postalCode, 'postalCode', false, issues, [...addressPath, 'postalCode']),
+            country: validateString(addressObj.country, 'country', false, issues, [...addressPath, 'country']),
+            type: validateString(addressObj.type, 'type', false, issues, [...addressPath, 'type']),
+            primary: validateBoolean(addressObj.primary, 'primary', issues, [...addressPath, 'primary']),
+        });
+    }
+    return addresses.length > 0 ? addresses : undefined;
+}
+/**
+ * Validates a SCIM Group array
+ */
+function validateGroups(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'groups must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const groups = [];
+    for (let i = 0; i < value.length; i++) {
+        const group = value[i];
+        const groupPath = [...basePath, i];
+        if (typeof group !== 'object' || group === null) {
+            issues.push({
+                message: 'group must be an object',
+                path: groupPath,
+            });
+            continue;
+        }
+        const groupObj = group;
+        const groupValue = validateString(groupObj.value, 'value', true, issues, [...groupPath, 'value']);
+        if (groupValue) {
+            groups.push({
+                value: groupValue,
+                $ref: validateString(groupObj.$ref, '$ref', false, issues, [...groupPath, '$ref']),
+                display: validateString(groupObj.display, 'display', false, issues, [...groupPath, 'display']),
+                type: validateString(groupObj.type, 'type', false, issues, [...groupPath, 'type']),
+            });
+        }
+    }
+    return groups.length > 0 ? groups : undefined;
+}
+/**
+ * Validates a SCIM Role array
+ */
+function validateRoles(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'roles must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const roles = [];
+    for (let i = 0; i < value.length; i++) {
+        const role = value[i];
+        const rolePath = [...basePath, i];
+        if (typeof role !== 'object' || role === null) {
+            issues.push({
+                message: 'role must be an object',
+                path: rolePath,
+            });
+            continue;
+        }
+        const roleObj = role;
+        const roleValue = validateString(roleObj.value, 'value', true, issues, [...rolePath, 'value']);
+        if (roleValue) {
+            roles.push({
+                value: roleValue,
+                display: validateString(roleObj.display, 'display', false, issues, [...rolePath, 'display']),
+                type: validateString(roleObj.type, 'type', false, issues, [...rolePath, 'type']),
+                primary: validateBoolean(roleObj.primary, 'primary', issues, [...rolePath, 'primary']),
+            });
+        }
+    }
+    return roles.length > 0 ? roles : undefined;
+}
+/**
+ * Validates a SCIM Enterprise User extension
+ */
+function validateEnterpriseUser(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'object' || value === null) {
+        issues.push({
+            message: 'Enterprise User extension must be an object',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const enterprise = value;
+    const result = {};
+    result.employeeNumber = validateString(enterprise.employeeNumber, 'employeeNumber', false, issues, [
+        ...basePath,
+        'employeeNumber',
+    ]);
+    result.costCenter = validateString(enterprise.costCenter, 'costCenter', false, issues, [...basePath, 'costCenter']);
+    result.organization = validateString(enterprise.organization, 'organization', false, issues, [
+        ...basePath,
+        'organization',
+    ]);
+    result.division = validateString(enterprise.division, 'division', false, issues, [...basePath, 'division']);
+    result.department = validateString(enterprise.department, 'department', false, issues, [...basePath, 'department']);
+    if (enterprise.manager !== undefined && enterprise.manager !== null) {
+        if (typeof enterprise.manager !== 'object' || enterprise.manager === null) {
+            issues.push({
+                message: 'manager must be an object',
+                path: [...basePath, 'manager'],
+            });
+        }
+        else {
+            const manager = enterprise.manager;
+            result.manager = {
+                value: validateString(manager.value, 'value', false, issues, [...basePath, 'manager', 'value']),
+                $ref: validateString(manager.$ref, '$ref', false, issues, [...basePath, 'manager', '$ref']),
+                displayName: validateString(manager.displayName, 'displayName', false, issues, [
+                    ...basePath,
+                    'manager',
+                    'displayName',
+                ]),
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Creates a StandardSchemaV1 for validating SCIM User resources.
+ * @param vendor - The name of the vendor creating this schema
+ * @returns A StandardSchemaV1 instance for SCIM User resources
+ */
+export function userSchema(vendor) {
+    return {
+        '~standard': {
+            version: 1,
+            vendor,
+            validate: (value) => {
+                if (typeof value !== 'object' || value === null) {
+                    return {
+                        issues: [
+                            {
+                                message: 'Expected an object',
+                            },
+                        ],
+                    };
+                }
+                const user = value;
+                const issues = [];
+                const result = {};
+                // userName is REQUIRED
+                const userName = validateString(user.userName, 'userName', true, issues, ['userName']);
+                if (!userName) {
+                    return { issues };
+                }
+                result.userName = userName;
+                // Optional string fields
+                result.id = validateString(user.id, 'id', false, issues, ['id']);
+                result.externalId = validateString(user.externalId, 'externalId', false, issues, ['externalId']);
+                result.displayName = validateString(user.displayName, 'displayName', false, issues, ['displayName']);
+                result.nickName = validateString(user.nickName, 'nickName', false, issues, ['nickName']);
+                result.profileUrl = validateString(user.profileUrl, 'profileUrl', false, issues, ['profileUrl']);
+                result.title = validateString(user.title, 'title', false, issues, ['title']);
+                result.userType = validateString(user.userType, 'userType', false, issues, ['userType']);
+                result.preferredLanguage = validateString(user.preferredLanguage, 'preferredLanguage', false, issues, [
+                    'preferredLanguage',
+                ]);
+                result.locale = validateString(user.locale, 'locale', false, issues, ['locale']);
+                result.timezone = validateString(user.timezone, 'timezone', false, issues, ['timezone']);
+                result.password = validateString(user.password, 'password', false, issues, ['password']);
+                // Boolean field
+                result.active = validateBoolean(user.active, 'active', issues, ['active']);
+                // Complex sub-attributes
+                result.name = validateName(user.name, issues, ['name']);
+                result.emails = validateEmails(user.emails, issues, ['emails']);
+                result.phoneNumbers = validatePhoneNumbers(user.phoneNumbers, issues, ['phoneNumbers']);
+                result.addresses = validateAddresses(user.addresses, issues, ['addresses']);
+                result.groups = validateGroups(user.groups, issues, ['groups']);
+                result.roles = validateRoles(user.roles, issues, ['roles']);
+                // Enterprise User Extension
+                const enterpriseKey = 'urn:ietf:params:scim:schemas:extension:enterprise:2.0:User';
+                if (user[enterpriseKey] !== undefined) {
+                    result[enterpriseKey] = validateEnterpriseUser(user[enterpriseKey], issues, [enterpriseKey]);
+                }
+                // Schemas array
+                if (user.schemas !== undefined) {
+                    if (Array.isArray(user.schemas)) {
+                        result.schemas = user.schemas.filter((s) => typeof s === 'string');
+                    }
+                    else {
+                        issues.push({
+                            message: 'schemas must be an array',
+                            path: ['schemas'],
+                        });
+                    }
+                }
+                // Meta object (basic validation)
+                if (user.meta !== undefined) {
+                    if (typeof user.meta === 'object' && user.meta !== null) {
+                        const meta = user.meta;
+                        result.meta = {
+                            resourceType: typeof meta.resourceType === 'string' ? meta.resourceType : undefined,
+                            created: typeof meta.created === 'string' ? meta.created : undefined,
+                            lastModified: typeof meta.lastModified === 'string' ? meta.lastModified : undefined,
+                            location: typeof meta.location === 'string' ? meta.location : undefined,
+                            version: typeof meta.version === 'string' ? meta.version : undefined,
+                        };
+                    }
+                    else {
+                        issues.push({
+                            message: 'meta must be an object',
+                            path: ['meta'],
+                        });
+                    }
+                }
+                if (issues.length > 0) {
+                    return { issues };
+                }
+                return { value: result };
+            },
+        },
+    };
+}
+/**
+ * Validates a SCIM GroupMember array
+ */
+function validateMembers(value, issues, basePath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({
+            message: 'members must be an array',
+            path: basePath,
+        });
+        return undefined;
+    }
+    const members = [];
+    for (let i = 0; i < value.length; i++) {
+        const member = value[i];
+        const memberPath = [...basePath, i];
+        if (typeof member !== 'object' || member === null) {
+            issues.push({
+                message: 'member must be an object',
+                path: memberPath,
+            });
+            continue;
+        }
+        const memberObj = member;
+        const memberValue = validateString(memberObj.value, 'value', true, issues, [...memberPath, 'value']);
+        if (memberValue) {
+            const memberType = validateString(memberObj.type, 'type', false, issues, [...memberPath, 'type']);
+            members.push({
+                value: memberValue,
+                $ref: validateString(memberObj.$ref, '$ref', false, issues, [...memberPath, '$ref']),
+                display: validateString(memberObj.display, 'display', false, issues, [...memberPath, 'display']),
+                type: memberType === 'User' || memberType === 'Group' ? memberType : undefined,
+            });
+        }
+    }
+    return members.length > 0 ? members : undefined;
+}
+/**
+ * Creates a StandardSchemaV1 for validating SCIM Group resources.
+ * @param vendor - The name of the vendor creating this schema
+ * @returns A StandardSchemaV1 instance for SCIM Group resources
+ */
+export function groupResourceSchema(vendor) {
+    return {
+        '~standard': {
+            version: 1,
+            vendor,
+            validate: (value) => {
+                if (typeof value !== 'object' || value === null) {
+                    return {
+                        issues: [
+                            {
+                                message: 'Expected an object',
+                            },
+                        ],
+                    };
+                }
+                const group = value;
+                const issues = [];
+                const result = {};
+                // displayName is REQUIRED
+                const displayName = validateString(group.displayName, 'displayName', true, issues, ['displayName']);
+                if (!displayName) {
+                    return { issues };
+                }
+                result.displayName = displayName;
+                // Optional string fields
+                result.id = validateString(group.id, 'id', false, issues, ['id']);
+                result.externalId = validateString(group.externalId, 'externalId', false, issues, ['externalId']);
+                // Members array
+                result.members = validateMembers(group.members, issues, ['members']);
+                // Schemas array
+                if (group.schemas !== undefined) {
+                    if (Array.isArray(group.schemas)) {
+                        result.schemas = group.schemas.filter((s) => typeof s === 'string');
+                    }
+                    else {
+                        issues.push({
+                            message: 'schemas must be an array',
+                            path: ['schemas'],
+                        });
+                    }
+                }
+                // Meta object (basic validation)
+                if (group.meta !== undefined) {
+                    if (typeof group.meta === 'object' && group.meta !== null) {
+                        const meta = group.meta;
+                        result.meta = {
+                            resourceType: typeof meta.resourceType === 'string' ? meta.resourceType : undefined,
+                            created: typeof meta.created === 'string' ? meta.created : undefined,
+                            lastModified: typeof meta.lastModified === 'string' ? meta.lastModified : undefined,
+                            location: typeof meta.location === 'string' ? meta.location : undefined,
+                            version: typeof meta.version === 'string' ? meta.version : undefined,
+                        };
+                    }
+                    else {
+                        issues.push({
+                            message: 'meta must be an object',
+                            path: ['meta'],
+                        });
+                    }
+                }
+                if (issues.length > 0) {
+                    return { issues };
+                }
+                return { value: result };
+            },
+        },
+    };
+}

package/dist/types/standard-schema.js

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

package/dist/types/user.js

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