@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Cli/Routing/Data/Option/SilentOptionParameter.ts

@@ -0,0 +1,30 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { OptionName } from '../../Constant/OptionName.js';
+import { OptionShortName } from '../../Constant/OptionShortName.js';
+import { OptionValueMode } from '../../Enum/OptionValueMode.js';
+import { OptionParameter } from '../OptionParameter.js';
+
+export class SilentOptionParameter extends OptionParameter {
+    constructor() {
+        super(
+            OptionName.SILENT,
+            'All output is suppressed',
+            '',
+            null,
+            '',
+            [OptionShortName.SILENT],
+            [],
+            [],
+            undefined,
+            OptionValueMode.NONE,
+        );
+    }
+}

package/src/Valkyrja/Cli/Routing/Data/Option/VersionOptionParameter.ts

@@ -0,0 +1,30 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { OptionName } from '../../Constant/OptionName.js';
+import { OptionShortName } from '../../Constant/OptionShortName.js';
+import { OptionValueMode } from '../../Enum/OptionValueMode.js';
+import { OptionParameter } from '../OptionParameter.js';
+
+export class VersionOptionParameter extends OptionParameter {
+    constructor() {
+        super(
+            OptionName.VERSION,
+            'Application version',
+            '',
+            null,
+            '',
+            [OptionShortName.VERSION],
+            [],
+            [],
+            undefined,
+            OptionValueMode.NONE,
+        );
+    }
+}

package/src/Valkyrja/Cli/Routing/Data/OptionParameter.ts

@@ -0,0 +1,188 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { OptionContract } from '../../Interaction/Option/Contract/OptionContract.js';
+import type { OptionParameterContract } from './Contract/OptionParameterContract.js';
+import type { Cast } from '../../../Type/Data/Cast.js';
+import { OptionMode } from '../Enum/OptionMode.js';
+import { OptionValueMode } from '../Enum/OptionValueMode.js';
+import { CliRoutingInvalidOptionWithValueException } from '../Throwable/Exception/CliRoutingInvalidOptionWithValueException.js';
+import { CliRoutingOptionValuesValidationException } from '../Throwable/Exception/CliRoutingOptionValuesValidationException.js';
+import { Parameter } from './Abstract/Parameter.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class OptionParameter extends Parameter implements OptionParameterContract {
+    constructor(
+        name: string,
+        description: string,
+        protected valueDisplayName: string = '',
+        cast: Cast | null = null,
+        protected defaultValue: string = '',
+        protected shortNames: string[] = [],
+        protected validValues: string[] = [],
+        protected options: OptionContract[] = [],
+        protected mode: OptionMode = OptionMode.OPTIONAL,
+        protected valueMode: OptionValueMode = OptionValueMode.DEFAULT,
+    ) {
+        super(name, description, cast);
+    }
+
+    getShortNames(): string[] {
+        return this.shortNames;
+    }
+
+    withShortNames(...shortNames: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.shortNames = shortNames;
+        return clone;
+    }
+
+    withAddedShortNames(...shortNames: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        const existing = new Set(clone.shortNames);
+        for (const n of shortNames) {
+            if (!existing.has(n)) {
+                existing.add(n);
+            }
+        }
+        clone.shortNames = [...existing];
+        return clone;
+    }
+
+    getMode(): OptionMode {
+        return this.mode;
+    }
+
+    withMode(mode: OptionMode): this {
+        const clone = ObjectFactory.clone(this);
+        clone.mode = mode;
+        return clone;
+    }
+
+    getValueMode(): OptionValueMode {
+        return this.valueMode;
+    }
+
+    withValueMode(valueMode: OptionValueMode): this {
+        const clone = ObjectFactory.clone(this);
+        clone.valueMode = valueMode;
+        return clone;
+    }
+
+    hasValueDisplayName(): boolean {
+        return this.valueDisplayName !== '';
+    }
+
+    getValueDisplayName(): string {
+        return this.valueDisplayName;
+    }
+
+    withValueDisplayName(valueName: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.valueDisplayName = valueName;
+        return clone;
+    }
+
+    getValidValues(): string[] {
+        return this.validValues;
+    }
+
+    withValidValues(...validValues: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.validValues = validValues;
+        return clone;
+    }
+
+    withAddedValidValues(...validValues: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        const existing = new Set(clone.validValues);
+        for (const v of validValues) {
+            if (!existing.has(v)) {
+                existing.add(v);
+            }
+        }
+        clone.validValues = [...existing];
+        return clone;
+    }
+
+    hasDefaultValue(): boolean {
+        return this.defaultValue !== '';
+    }
+
+    getDefaultValue(): string {
+        return this.defaultValue;
+    }
+
+    withDefaultValue(defaultValue: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.defaultValue = defaultValue;
+        return clone;
+    }
+
+    getOptions(): OptionContract[] {
+        return this.options;
+    }
+
+    withOptions(...options: OptionContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.options = [];
+        for (const option of options) {
+            if (this.valueMode === OptionValueMode.NONE && option.hasValue()) {
+                throw new CliRoutingInvalidOptionWithValueException(`${this.name} should have no value`);
+            }
+            clone.options.push(option);
+        }
+        return clone;
+    }
+
+    withAddedOptions(...options: OptionContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.options = [...this.options];
+        for (const option of options) {
+            if (this.valueMode === OptionValueMode.NONE && option.hasValue()) {
+                throw new CliRoutingInvalidOptionWithValueException(`${this.name} should have no value`);
+            }
+            clone.options.push(option);
+        }
+        return clone;
+    }
+
+    getCastValues(): unknown[] {
+        return this.getCastValuesForParameters(this.options);
+    }
+
+    hasFirstValue(): boolean {
+        return this.options.length > 0;
+    }
+
+    getFirstValue(): string {
+        return this.options[0]?.getValue() ?? '';
+    }
+
+    areValuesValid(): boolean {
+        let valid = true;
+
+        if (this.mode === OptionMode.REQUIRED) {
+            valid = this.options.length > 0;
+        }
+
+        if (this.valueMode === OptionValueMode.DEFAULT) {
+            valid = valid && this.options.length <= 1;
+        }
+
+        return valid;
+    }
+
+    validateValues(): this {
+        if (!this.areValuesValid()) {
+            throw new CliRoutingOptionValuesValidationException(`${this.name} is invalid`);
+        }
+        return this;
+    }
+}

package/src/Valkyrja/Cli/Routing/Data/Route.ts

@@ -0,0 +1,211 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { MessageContract } from '../../Interaction/Message/Contract/MessageContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ArgumentParameterContract } from './Contract/ArgumentParameterContract.js';
+import type { OptionParameterContract } from './Contract/OptionParameterContract.js';
+import type { RouteContract } from './Contract/RouteContract.js';
+import { CliRoutingInvalidArgumentNameException } from '../Throwable/Exception/CliRoutingInvalidArgumentNameException.js';
+import { CliRoutingInvalidOptionNameException } from '../Throwable/Exception/CliRoutingInvalidOptionNameException.js';
+import { CliRoutingNoHelpTextException } from '../Throwable/Exception/CliRoutingNoHelpTextException.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Route implements RouteContract {
+    constructor(
+        protected name: string,
+        protected description: string,
+        protected handler: (container: ContainerContract, route: RouteContract) => OutputContract,
+        protected helpText: (() => MessageContract) | null = null,
+        protected routeMatchedMiddleware: string[] = [],
+        protected routeDispatchedMiddleware: string[] = [],
+        protected throwableCaughtMiddleware: string[] = [],
+        protected exitedMiddleware: string[] = [],
+        protected arguments_: ArgumentParameterContract[] = [],
+        protected options: OptionParameterContract[] = [],
+    ) {}
+
+    getName(): string {
+        return this.name;
+    }
+
+    withName(name: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.name = name;
+        return clone;
+    }
+
+    getDescription(): string {
+        return this.description;
+    }
+
+    withDescription(description: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.description = description;
+        return clone;
+    }
+
+    hasHelpText(): boolean {
+        return this.helpText !== null;
+    }
+
+    getHelpText(): () => MessageContract {
+        if (this.helpText === null) {
+            throw new CliRoutingNoHelpTextException('No help text has been set for this route');
+        }
+        return this.helpText;
+    }
+
+    getHelpTextMessage(): MessageContract {
+        return this.getHelpText()();
+    }
+
+    withHelpText(helpText: () => MessageContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.helpText = helpText;
+        return clone;
+    }
+
+    hasArguments(): boolean {
+        return this.arguments_.length > 0;
+    }
+    getArguments(): ArgumentParameterContract[] {
+        return this.arguments_;
+    }
+
+    hasArgument(name: string): boolean {
+        return this.arguments_.some((a) => a.getName() === name);
+    }
+
+    getArgument(name: string): ArgumentParameterContract {
+        const found = this.arguments_.find((a) => a.getName() === name);
+        if (found === undefined) {
+            throw new CliRoutingInvalidArgumentNameException(`The argument \`${name}\` was not found`);
+        }
+        return found;
+    }
+
+    withArguments(...arguments_: ArgumentParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.arguments_ = arguments_;
+        return clone;
+    }
+
+    withAddedArguments(...arguments_: ArgumentParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.arguments_ = [...this.arguments_, ...arguments_];
+        return clone;
+    }
+
+    hasOptions(): boolean {
+        return this.options.length > 0;
+    }
+    getOptions(): OptionParameterContract[] {
+        return this.options;
+    }
+
+    hasOption(name: string): boolean {
+        return this.options.some((o) => o.getName() === name);
+    }
+
+    getOption(name: string): OptionParameterContract {
+        const found = this.options.find((o) => o.getName() === name);
+        if (found === undefined) {
+            throw new CliRoutingInvalidOptionNameException(`The option \`${name}\` was not found`);
+        }
+        return found;
+    }
+
+    withOptions(...options: OptionParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.options = options;
+        return clone;
+    }
+
+    withAddedOptions(...options: OptionParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.options = [...this.options, ...options];
+        return clone;
+    }
+
+    getRouteMatchedMiddleware(): string[] {
+        return this.routeMatchedMiddleware;
+    }
+
+    withRouteMatchedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeMatchedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedRouteMatchedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeMatchedMiddleware = [...this.routeMatchedMiddleware, ...middleware];
+        return clone;
+    }
+
+    getRouteDispatchedMiddleware(): string[] {
+        return this.routeDispatchedMiddleware;
+    }
+
+    withRouteDispatchedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeDispatchedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedRouteDispatchedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeDispatchedMiddleware = [...this.routeDispatchedMiddleware, ...middleware];
+        return clone;
+    }
+
+    getThrowableCaughtMiddleware(): string[] {
+        return this.throwableCaughtMiddleware;
+    }
+
+    withThrowableCaughtMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.throwableCaughtMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedThrowableCaughtMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.throwableCaughtMiddleware = [...this.throwableCaughtMiddleware, ...middleware];
+        return clone;
+    }
+
+    getExitedMiddleware(): string[] {
+        return this.exitedMiddleware;
+    }
+
+    withExitedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.exitedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedExitedMiddleware(...middleware: string[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.exitedMiddleware = [...this.exitedMiddleware, ...middleware];
+        return clone;
+    }
+
+    getHandler(): (container: ContainerContract, route: RouteContract) => OutputContract {
+        return this.handler;
+    }
+
+    withHandler(handler: (container: ContainerContract, route: RouteContract) => OutputContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.handler = handler;
+        return clone;
+    }
+}

package/src/Valkyrja/Cli/Routing/Dispatcher/Contract/RouterContract.ts

@@ -0,0 +1,23 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../Data/Contract/RouteContract.js';
+
+export interface RouterContract {
+    dispatch(input: InputContract): OutputContract;
+    dispatchRoute(input: InputContract, route: RouteContract): OutputContract;
+}
+
+export namespace RouterContract {
+    export function instanceOf(value: unknown): value is RouterContract {
+        return typeof value === 'object' && value !== null && 'dispatch' in value;
+    }
+}

package/src/Valkyrja/Cli/Routing/Dispatcher/Router.ts

@@ -0,0 +1,155 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Container } from '../../../Container/Manager/Container.js';
+import { ExitCode } from '../../Interaction/Enum/ExitCode.js';
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import { Banner } from '../../Interaction/Message/Banner.js';
+import { ErrorMessage } from '../../Interaction/Message/ErrorMessage.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import { OutputFactory } from '../../Interaction/Output/Factory/OutputFactory.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import { ExitedHandler } from '../../Middleware/Handler/ExitedHandler.js';
+import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.js';
+import { RouteDispatchedHandler } from '../../Middleware/Handler/RouteDispatchedHandler.js';
+import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.js';
+import { RouteMatchedHandler } from '../../Middleware/Handler/RouteMatchedHandler.js';
+import type { RouteMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteMatchedHandlerContract.js';
+import { RouteNotMatchedHandler } from '../../Middleware/Handler/RouteNotMatchedHandler.js';
+import type { RouteNotMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.js';
+import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.js';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+import { RouteCollection } from '../Collection/RouteCollection.js';
+import type { RouteCollectionContract } from '../Collection/Contract/RouteCollectionContract.js';
+import type { ArgumentParameterContract } from '../Data/Contract/ArgumentParameterContract.js';
+import type { OptionParameterContract } from '../Data/Contract/OptionParameterContract.js';
+import type { RouteContract } from '../Data/Contract/RouteContract.js';
+import { ArgumentValueMode } from '../Enum/ArgumentValueMode.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import { CliRoutingServiceId } from '../Constant/CliRoutingServiceId.js';
+import type { RouterContract } from './Contract/RouterContract.js';
+
+export class Router implements RouterContract {
+    constructor(
+        protected container: ContainerContract = new Container(),
+        protected collection: RouteCollectionContract = new RouteCollection(),
+        protected outputFactory: OutputFactoryContract = new OutputFactory(),
+        protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
+        protected routeMatchedHandler: RouteMatchedHandlerContract = new RouteMatchedHandler(),
+        protected routeNotMatchedHandler: RouteNotMatchedHandlerContract = new RouteNotMatchedHandler(),
+        protected routeDispatchedHandler: RouteDispatchedHandlerContract = new RouteDispatchedHandler(),
+        protected exitedHandler: ExitedHandlerContract = new ExitedHandler(),
+    ) {}
+
+    dispatch(input: InputContract): OutputContract {
+        const matchedRoute = this.attemptToMatchRoute(input);
+
+        if (!this.isRouteContract(matchedRoute)) {
+            return this.routeNotMatchedHandler.routeNotMatched(input, matchedRoute);
+        }
+
+        return this.dispatchRoute(input, matchedRoute);
+    }
+
+    dispatchRoute(input: InputContract, route: RouteContract): OutputContract {
+        route = this.addParametersToRoute(input, route);
+
+        this.routeMatched(route);
+
+        const routeAfterMiddleware = this.routeMatchedHandler.routeMatched(input, route);
+
+        if (!this.isRouteContract(routeAfterMiddleware)) {
+            return routeAfterMiddleware;
+        }
+
+        this.container.setSingleton<RouteContract>(CliRoutingServiceId.RouteContract, routeAfterMiddleware);
+
+        const handler = routeAfterMiddleware.getHandler();
+        const output = handler(this.container, routeAfterMiddleware);
+
+        return this.routeDispatchedHandler.routeDispatched(input, output, routeAfterMiddleware);
+    }
+
+    protected attemptToMatchRoute(input: InputContract): RouteContract | OutputContract {
+        const commandName = input.getCommandName();
+
+        if (this.collection.has(commandName)) {
+            return this.collection.get(commandName);
+        }
+
+        const errorText = `Command \`${commandName}\` was not found.`;
+
+        return this.outputFactory.createOutput(ExitCode.ERROR).withMessages(new Banner(new ErrorMessage(errorText)));
+    }
+
+    protected addParametersToRoute(input: InputContract, route: RouteContract): RouteContract {
+        route = this.addArgumentsToRoute(input, route);
+
+        return this.addOptionsToRoute(input, route);
+    }
+
+    protected addArgumentsToRoute(input: InputContract, route: RouteContract): RouteContract {
+        const arguments_ = [...input.getArguments()];
+        const argumentParameters = route.getArguments();
+        const updatedParams: ArgumentParameterContract[] = [];
+
+        for (let i = 0; i < argumentParameters.length; i++) {
+            const param = argumentParameters[i];
+
+            if (param === undefined) {
+                continue;
+            }
+
+            let paramArguments: typeof arguments_ = [];
+
+            if (param.getValueMode() === ArgumentValueMode.ARRAY) {
+                paramArguments = arguments_.splice(0);
+            } else {
+                const arg = arguments_[i];
+                if (arg !== undefined) {
+                    paramArguments = [arg];
+                    arguments_.splice(i, 1);
+                }
+            }
+
+            updatedParams.push(param.withArguments(...paramArguments).validateValues());
+        }
+
+        return route.withArguments(...updatedParams);
+    }
+
+    protected addOptionsToRoute(input: InputContract, route: RouteContract): RouteContract {
+        const options = input.getOptions();
+        const optionParameters = [...route.getOptions()];
+        const updatedParams: OptionParameterContract[] = [];
+
+        for (const param of optionParameters) {
+            const paramOptions = options.filter(
+                (opt) => param.getName() === opt.getName() || param.getShortNames().includes(opt.getName()),
+            );
+
+            updatedParams.push(param.withOptions(...paramOptions).validateValues());
+        }
+
+        return route.withOptions(...updatedParams);
+    }
+
+    protected routeMatched(route: RouteContract): void {
+        this.routeMatchedHandler.add(...route.getRouteMatchedMiddleware());
+        this.routeDispatchedHandler.add(...route.getRouteDispatchedMiddleware());
+        this.throwableCaughtHandler.add(...route.getThrowableCaughtMiddleware());
+        this.exitedHandler.add(...route.getExitedMiddleware());
+
+        this.container.setSingleton<RouteContract>(CliRoutingServiceId.RouteContract, route);
+    }
+
+    protected isRouteContract(value: RouteContract | OutputContract): value is RouteContract {
+        return 'getHandler' in value;
+    }
+}

package/src/Valkyrja/Cli/Routing/Enum/ArgumentMode.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export enum ArgumentMode {
+    REQUIRED = 'REQUIRED',
+    OPTIONAL = 'OPTIONAL',
+}

package/src/Valkyrja/Cli/Routing/Enum/ArgumentValueMode.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export enum ArgumentValueMode {
+    DEFAULT = 'DEFAULT',
+    ARRAY = 'ARRAY',
+}

package/src/Valkyrja/Cli/Routing/Enum/OptionMode.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export enum OptionMode {
+    REQUIRED = 'REQUIRED',
+    OPTIONAL = 'OPTIONAL',
+}