@userfrosting/sprinkle-core 6.0.0-alpha.6 → 6.0.0-beta.2

package/app/assets/composables/index.ts

@@ -1,3 +1,4 @@
 export { useSprunjer } from './useSprunjer'
 export { useCsrf } from './useCsrf'
 export { useAxiosInterceptor } from './useAxiosInterceptor'
+export { useRuleSchemaAdapter } from './useRuleSchemaAdapter'

package/app/assets/composables/useRuleSchemaAdapter.ts

@@ -0,0 +1,219 @@
+import { parse as YamlParse } from 'yaml'
+import {
+    withMessage,
+    required,
+    maxLength,
+    minLength,
+    email,
+    integer,
+    numeric,
+    url,
+    oneOf,
+    between,
+    regex,
+    not
+} from '@regle/rules'
+import { useTranslator } from '../stores'
+
+export function useRuleSchemaAdapter() {
+    /**
+     * Parse the YAML schema string into a JavaScript object.
+     *
+     * @param rawSchema The YAML schema string to parse.
+     * @returns RuleSchema The Regle schema object.
+     */
+    function adapt(rawSchema: string) {
+        // The YAML data parsed to a JavaScript object
+        const sourceSchema = parse(rawSchema)
+
+        // The Regle schema object to be returned
+        const regleSchema: any = {}
+
+        // Iterate over each field in the schema
+        for (const field in sourceSchema) {
+            // Check if the field is a direct property of the sourceSchema object
+            if (Object.prototype.hasOwnProperty.call(sourceSchema, field)) {
+                // Get the field rules from the source schema
+                const schemaFieldRules = sourceSchema[field]?.validators || {}
+
+                // The returned regle rules for the field
+                const regleRules: Record<string, any> = {}
+
+                // Iterate over each rule in the source schema field rules
+                for (const key of Object.keys(schemaFieldRules)) {
+                    adaptRule(key, schemaFieldRules, regleRules)
+                }
+
+                regleSchema[field] = regleRules
+            }
+        }
+
+        return regleSchema
+    }
+
+    /**
+     * Parse the YAML schema string into a JavaScript object.
+     *
+     * @param rawSchema The YAML schema string to parse.
+     * @returns The parsed YAML schema as a JavaScript object.
+     */
+    function parse(rawSchema: string): Record<string, any> {
+        return YamlParse(rawSchema)
+    }
+
+    function translateMessage(fieldRulesMeta: { message?: string; [key: string]: any }): string {
+        const { translate } = useTranslator()
+
+        // If there's no message, return an empty string
+        if (!fieldRulesMeta.message) {
+            return ''
+        }
+
+        // Copy the field rules meta to avoid mutation and remove the message key
+        const fieldRulesMetaCopy = { ...fieldRulesMeta }
+        delete fieldRulesMetaCopy.message
+
+        return translate(fieldRulesMeta.message, fieldRulesMetaCopy)
+    }
+
+    function adaptRule(key: string, schemaFieldRules: any, regleRules: Record<string, any>) {
+        // Required
+        if (key === 'required' && schemaFieldRules.required) {
+            const message: string = translateMessage(schemaFieldRules.required)
+            regleRules['required'] = message === '' ? required : withMessage(required, message)
+        }
+
+        // Email
+        if (key === 'email' && schemaFieldRules.email) {
+            const message: string = translateMessage(schemaFieldRules.email)
+            regleRules['email'] = withMessage(email, message)
+        }
+
+        // Length
+        if (key === 'length' && schemaFieldRules.length) {
+            if (schemaFieldRules.length.min !== undefined) {
+                const message: string = translateMessage(schemaFieldRules.length)
+                regleRules['minLength'] =
+                    message === ''
+                        ? minLength(schemaFieldRules.length.min)
+                        : withMessage(minLength(schemaFieldRules.length.min), message)
+            }
+            if (schemaFieldRules.length.max !== undefined) {
+                const message: string = translateMessage(schemaFieldRules.length)
+                regleRules['maxLength'] =
+                    message === ''
+                        ? maxLength(schemaFieldRules.length.max)
+                        : withMessage(maxLength(schemaFieldRules.length.max), message)
+            }
+        }
+
+        // TODO : matches
+        if (key === 'matches' && schemaFieldRules.matches) {
+            console.warn('Validation rule "matches" not implemented yet')
+            // console.debug('Matched rule: matches', schemaFieldRules.matches)
+            // sameAs: sameAs(() => form.value.password),
+        }
+
+        // TODO : equals
+        if (key === 'equals' && schemaFieldRules.equals) {
+            console.warn('Validation rule "equals" not implemented yet')
+        }
+
+        // Integer
+        if (key === 'integer' && schemaFieldRules.integer) {
+            const message: string = translateMessage(schemaFieldRules.integer)
+            regleRules['integer'] = message === '' ? integer : withMessage(integer, message)
+        }
+
+        // member_of
+        if (key === 'member_of' && schemaFieldRules.member_of) {
+            const message: string = translateMessage(schemaFieldRules.member_of)
+            regleRules['member_of'] =
+                message === ''
+                    ? oneOf(schemaFieldRules.member_of.values)
+                    : withMessage(oneOf(schemaFieldRules.member_of.values), message)
+        }
+
+        // no_leading_whitespace
+        if (key === 'no_leading_whitespace' && schemaFieldRules.no_leading_whitespace) {
+            const message: string = translateMessage(schemaFieldRules.no_leading_whitespace)
+            regleRules['no_leading_whitespace'] =
+                message === '' ? regex(/^\S.*$/) : withMessage(regex(/^\S.*$/), message)
+        }
+
+        // no_trailing_whitespace
+        if (key === 'no_trailing_whitespace' && schemaFieldRules.no_trailing_whitespace) {
+            const message: string = translateMessage(schemaFieldRules.no_trailing_whitespace)
+            regleRules['no_trailing_whitespace'] =
+                message === '' ? regex(/^.*\S$/) : withMessage(regex(/^.*\S$/), message)
+        }
+
+        // TODO : not_equals
+        if (key === 'not_equals' && schemaFieldRules.not_equals) {
+            console.warn('Validation rule "not_equals" not implemented yet')
+        }
+
+        // TODO : not_matches
+        if (key === 'not_matches' && schemaFieldRules.not_matches) {
+            console.warn('Validation rule "not_matches" not implemented yet')
+        }
+
+        // not_member_of
+        if (key === 'not_member_of' && schemaFieldRules.not_member_of) {
+            const message: string = translateMessage(schemaFieldRules.not_member_of)
+            regleRules['not_member_of'] =
+                message === ''
+                    ? not(oneOf(schemaFieldRules.not_member_of.values))
+                    : withMessage(not(oneOf(schemaFieldRules.not_member_of.values)), message)
+        }
+
+        // Numeric
+        if (key === 'numeric' && schemaFieldRules.numeric) {
+            const message: string = translateMessage(schemaFieldRules.numeric)
+            regleRules['numeric'] = message === '' ? numeric : withMessage(numeric, message)
+        }
+
+        // Range
+        if (key === 'range' && schemaFieldRules.range) {
+            const message: string = translateMessage(schemaFieldRules.range)
+            regleRules['range'] =
+                message === ''
+                    ? between(schemaFieldRules.range.min, schemaFieldRules.range.max)
+                    : withMessage(
+                          between(schemaFieldRules.range.min, schemaFieldRules.range.max),
+                          message
+                      )
+        }
+
+        // Regex
+        if (key === 'regex' && schemaFieldRules.regex) {
+            const message: string = translateMessage(schemaFieldRules.regex)
+            regleRules['regex'] =
+                message === ''
+                    ? regex(new RegExp(schemaFieldRules.regex.regex))
+                    : withMessage(regex(new RegExp(schemaFieldRules.regex.regex)), message)
+        }
+
+        // TODO : telephone
+        if (key === 'telephone' && schemaFieldRules.telephone) {
+            console.warn('Validation rule "telephone" not implemented yet')
+        }
+
+        // uri
+        if (key === 'uri' && schemaFieldRules.uri) {
+            const message: string = translateMessage(schemaFieldRules.uri)
+            regleRules['uri'] = message === '' ? url : withMessage(url, message)
+        }
+
+        // Username
+        if (key === 'username' && schemaFieldRules.username) {
+            const message: string = translateMessage(schemaFieldRules.username)
+            regleRules['username'] =
+                message === ''
+                    ? regex(/^([a-z0-9.\-_])+$/i)
+                    : withMessage(regex(/^([a-z0-9.\-_])+$/i), message)
+        }
+    }
+
+    return { adapt, parse, translateMessage }
+}

package/app/assets/tests/composables/useRuleSchemaAdapter.test.ts

@@ -0,0 +1,564 @@
+import { describe, test, expect, vi, afterEach } from 'vitest'
+import { useRuleSchemaAdapter } from '../../composables/useRuleSchemaAdapter'
+import { useRegle } from '@regle/core'
+
+// Mock the translator store
+const translateMock = vi.fn((key: string) => key || '')
+vi.mock('@userfrosting/sprinkle-core/stores', () => ({
+    useTranslator: () => ({
+        translate: translateMock
+    })
+}))
+
+describe('useRuleSchemaAdapter', () => {
+    afterEach(() => {
+        vi.clearAllMocks()
+    })
+
+    test('should parse a basic schema', () => {
+        const yamlInput = `
+            foo:
+                validators:
+                    length:
+                        min: 1
+                        max: 132
+                    required: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                foo: ''
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        expect(r$.foo).toBeDefined()
+        expect(r$.foo.$rules.required).toBeDefined()
+        expect(r$.foo.$rules.minLength).toBeDefined()
+        expect(r$.foo.$rules.maxLength).toBeDefined()
+    })
+
+    test('should parse a schema with a custom message', () => {
+        const yamlInput = `
+            name:
+                validators:
+                    length:
+                        min: 2
+                        max: 20
+                    required: true
+            email:
+                validators:
+                    length:
+                        min: 1
+                        max: 30
+                    email: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                name: '',
+                email: ''
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        expect(r$.name).toBeDefined()
+        expect(r$.name.$rules.required).toBeDefined()
+        expect(r$.name.$rules.minLength).toBeDefined()
+        expect(r$.name.$rules.maxLength).toBeDefined()
+        expect(r$.email).toBeDefined()
+        expect(r$.email.$rules.required).not.toBeDefined()
+        expect(r$.email.$rules.minLength).toBeDefined()
+        expect(r$.email.$rules.maxLength).toBeDefined()
+    })
+
+    test('should parse a bad schema without errors', () => {
+        // N.B.: The schema is missing the 'validators' key
+        const yamlInput = `
+            foo:
+                length:
+                    min: 1
+                    max: 132
+                required: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                foo: ''
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        expect(r$.foo).toBeDefined()
+        expect(r$.foo.$rules.required).not.toBeDefined()
+        expect(r$.foo.$rules.minLength).not.toBeDefined()
+        expect(r$.foo.$rules.maxLength).not.toBeDefined()
+    })
+
+    test('required rule', () => {
+        const yamlInput = `
+            first_name:
+                validators:
+                    required:
+                        label: "&FIRST_NAME"
+                        message: VALIDATE.REQUIRED
+            last_name:
+                validators:
+                    required: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                first_name: '',
+                last_name: ''
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.REQUIRED', {
+            label: '&FIRST_NAME'
+        })
+
+        expect(r$.first_name.$rules.required.$message).toBe('VALIDATE.REQUIRED') // Custom message
+        expect(r$.last_name.$rules.required.$message).toBe('This field is required') // Default message
+    })
+
+    test('email rule', () => {
+        const yamlInput = `
+            email:
+                validators:
+                    email:
+                        message: VALIDATE.INVALID_EMAIL
+            email2:
+                validators:
+                    email: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                email: '',
+                email2: ''
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_EMAIL', {})
+
+        expect(r$.email.$rules.email.$message).toBe('VALIDATE.INVALID_EMAIL') // Custom message
+        expect(r$.email2.$rules.email.$message).toBe('This field is not valid') // Default message
+    })
+
+    test('length rule', () => {
+        const yamlInput = `
+            tooShort:
+                validators:
+                    length:
+                        min: 5
+            tooLong:
+                validators:
+                    length:
+                        max: 2
+            tooShortWithMessage:
+                validators:
+                    length:
+                        min: 5
+                        message: VALIDATE.LENGTH_RANGE
+            tooLongWithMessage:
+                validators:
+                    length:
+                        max: 2
+                        message: VALIDATE.LENGTH_RANGE
+        `
+
+        const { r$ } = useRegle(
+            {
+                tooShort: '1',
+                tooLong: '123',
+                tooShortWithMessage: '1',
+                tooLongWithMessage: '123'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenNthCalledWith(1, 'VALIDATE.LENGTH_RANGE', { min: 5 })
+        expect(translateMock).toHaveBeenNthCalledWith(2, 'VALIDATE.LENGTH_RANGE', { max: 2 })
+
+        expect(r$.tooShort.$silentErrors).toEqual(['The value length should be at least 5']) // Custom message
+        expect(r$.tooLong.$silentErrors).toEqual(['The value length should not exceed 2']) // Default message
+        expect(r$.tooShortWithMessage.$silentErrors).toEqual(['VALIDATE.LENGTH_RANGE']) // Custom message
+        expect(r$.tooLongWithMessage.$silentErrors).toEqual(['VALIDATE.LENGTH_RANGE']) // Default message
+    })
+
+    test('integer rule', () => {
+        const yamlInput = `
+            foo:
+                validators:
+                    integer: true
+            bar:
+                validators:
+                    integer: 
+                        message: VALIDATE.INVALID_INTEGER
+            foobar:
+                validators:
+                    integer: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                foo: 'one',
+                bar: 'two',
+                foobar: 92
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_INTEGER', {})
+
+        expect(r$.foo.$silentErrors).toEqual(['The value must be an integer']) // Custom message
+        expect(r$.bar.$silentErrors).toEqual(['VALIDATE.INVALID_INTEGER']) // Default message
+        expect(r$.foobar.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('member_of rule', () => {
+        const yamlInput = `
+            genus:
+                validators:
+                    member_of:
+                        values:
+                        - Megascops
+                        - Bubo
+                        - Glaucidium
+                        - Tyto
+                        - Athene
+                        message: Sorry, that is not one of the permitted genuses.
+            owls:
+                validators:
+                    member_of:
+                        values:
+                        - Foo
+                        - Bar
+            valid:
+                validators:
+                    member_of:
+                        values:
+                        - Foo
+                        - Bar
+        `
+
+        const { r$ } = useRegle(
+            {
+                genus: 'Foo',
+                owls: 'Hedwig',
+                valid: 'Foo'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith(
+            'Sorry, that is not one of the permitted genuses.',
+            {
+                values: ['Megascops', 'Bubo', 'Glaucidium', 'Tyto', 'Athene']
+            }
+        )
+
+        expect(r$.genus.$silentErrors).toEqual(['Sorry, that is not one of the permitted genuses.']) // Custom message
+        expect(r$.owls.$silentErrors).toEqual([
+            'The value should be one of those options: Foo, Bar.'
+        ]) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('not_member_of rule', () => {
+        const yamlInput = `
+            genus:
+                validators:
+                    not_member_of:
+                        values:
+                        - Megascops
+                        - Bubo
+                        - Glaucidium
+                        - Tyto
+                        - Athene
+                        message: VALIDATE.NOT_MEMBER_OF
+            owls:
+                validators:
+                    not_member_of:
+                        values:
+                        - Foo
+                        - Bar
+            valid:
+                validators:
+                    not_member_of:
+                        values:
+                        - Foo
+                        - Bar
+        `
+
+        const { r$ } = useRegle(
+            {
+                genus: 'Megascops',
+                owls: 'Foo',
+                valid: 'Hedwig'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.NOT_MEMBER_OF', {
+            values: ['Megascops', 'Bubo', 'Glaucidium', 'Tyto', 'Athene']
+        })
+
+        expect(r$.genus.$silentErrors).toEqual(['VALIDATE.NOT_MEMBER_OF']) // Custom message
+        expect(r$.owls.$silentErrors).toEqual(['Error']) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('no_leading_whitespace rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    no_leading_whitespace:
+                        label: "&USERNAME"
+                        message: VALIDATE.NO_LEAD_WS
+            defaultMessage:
+                validators:
+                    no_leading_whitespace: true
+            valid:
+                validators:
+                    no_leading_whitespace: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: ' Foo',
+                defaultMessage: ' Foo',
+                valid: 'Foo'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.NO_LEAD_WS', {
+            label: '&USERNAME'
+        })
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.NO_LEAD_WS']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual([
+            'The value does not match the required pattern'
+        ]) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('no_trailing_whitespace rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    no_trailing_whitespace:
+                        label: "&USERNAME"
+                        message: VALIDATE.NO_TRAIL_WS
+            defaultMessage:
+                validators:
+                    no_trailing_whitespace: true
+            valid:
+                validators:
+                    no_trailing_whitespace: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 'Foo ',
+                defaultMessage: 'Foo ',
+                valid: 'Foo'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.NO_TRAIL_WS', {
+            label: '&USERNAME'
+        })
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.NO_TRAIL_WS']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual([
+            'The value does not match the required pattern'
+        ]) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('numeric rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    numeric:
+                        message: VALIDATE.INVALID_NUMERIC
+            defaultMessage:
+                validators:
+                    numeric: true
+            valid:
+                validators:
+                    numeric: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 'Foo',
+                defaultMessage: 'Foo',
+                valid: '10.2'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_NUMERIC', {})
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.INVALID_NUMERIC']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual(['The value must be numeric']) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('range rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    range:
+                        min: 0
+                        max: 10
+                        message: VALIDATE.INVALID_RANGE
+            defaultMessage:
+                validators:
+                    range: 
+                        min: 0
+                        max: 10
+            valid:
+                validators:
+                    range: 
+                        min: 0
+                        max: 10
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 92,
+                defaultMessage: 92,
+                valid: 9
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_RANGE', {
+            min: 0,
+            max: 10
+        })
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.INVALID_RANGE']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual(['The value must be between 0 and 10']) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('regex rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    regex:
+                        regex: ^who(o*)$
+                        message: VALIDATE.INVALID_VALUE
+            defaultMessage:
+                validators:
+                    regex: 
+                        regex: ^who(o*)$
+            valid:
+                validators:
+                    regex: 
+                        regex: ^who(o*)$
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 'hum',
+                defaultMessage: 'hello',
+                valid: 'whooo'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+        r$.$validate()
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_VALUE', {
+            regex: '^who(o*)$'
+        })
+
+        expect(r$.withMessage.$errors).toEqual(['VALIDATE.INVALID_VALUE']) // Custom message
+        expect(r$.defaultMessage.$errors).toEqual(['The value does not match the required pattern']) // Default message
+        expect(r$.valid.$correct).toEqual(true) // Valid
+    })
+
+    test('uri rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    uri:
+                        message: VALIDATE.INVALID_URL
+            defaultMessage:
+                validators:
+                    uri: true
+            valid:
+                validators:
+                    uri: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 'foo',
+                defaultMessage: 'bar@example.com',
+                valid: 'http://example.com'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_URL', {})
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.INVALID_URL']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual(['The value is not a valid URL address']) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+
+    test('username rule', () => {
+        const yamlInput = `
+            withMessage:
+                validators:
+                    username:
+                        message: VALIDATE.INVALID_USERNAME
+            defaultMessage:
+                validators:
+                    username: true
+            valid:
+                validators:
+                    username: true
+        `
+
+        const { r$ } = useRegle(
+            {
+                withMessage: 'My Name',
+                defaultMessage: 'bar@example.com',
+                valid: 'foo.bar-bax_123'
+            },
+            useRuleSchemaAdapter().adapt(yamlInput)
+        )
+
+        // Set translator expectations
+        expect(translateMock).toHaveBeenCalledExactlyOnceWith('VALIDATE.INVALID_USERNAME', {})
+
+        expect(r$.withMessage.$silentErrors).toEqual(['VALIDATE.INVALID_USERNAME']) // Custom message
+        expect(r$.defaultMessage.$silentErrors).toEqual([
+            'The value does not match the required pattern'
+        ]) // Default message
+        expect(r$.valid.$silentErrors).toEqual([]) // Valid
+    })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@userfrosting/sprinkle-core",
-    "version": "6.0.0-alpha.6",
+    "version": "6.0.0-beta.2",
     "type": "module",
     "description": "Core Sprinkle for UserFrosting",
     "funding": "https://opencollective.com/userfrosting",
@@ -34,8 +34,11 @@
         "app/assets/"
     ],
     "dependencies": {
+        "@regle/core": "^1.6.0",
+        "@regle/rules": "^1.6.0",
         "dot-prop": "^9.0.0",
-        "luxon": "^3.5.0"
+        "luxon": "^3.5.0",
+        "yaml": "^2.8.0"
     },
     "peerDependencies": {
         "axios": "^1.5.0",