raiton 1.1.1 → 3.0.0

package/source/core/thread.ts

@@ -0,0 +1,112 @@
+import type {
+    BuilderInterface,
+    RuntimeAdapterInterface,
+    RuntimeServerInterface,
+    ThreadInterface,
+    ThreadOptions,
+    ThreadSetupOptions,
+    ThreadWaitCallable,
+} from "@/types";
+import {EventMessageEnum, RuntimeType} from "@/sdk/enums";
+import {ProcessUtility} from "@protorians/core";
+import {until} from "./process.util";
+import {ApplicationInterface} from "@/types/application";
+import {Runtime} from "@/sdk/runtime";
+import {LBadge, Logger} from "@protorians/logger";
+import {ControllerBuilder} from "@/core/controller";
+import {bodyParserPlugin} from "@/sdk/plugins/body-parser.plugin";
+import {Injection} from "@/core/injection/injection";
+import {Throwable} from "@/sdk/exceptions";
+import os from "os";
+
+
+export class RaitonThread implements ThreadInterface {
+
+    protected static instance: RaitonThread | null = null;
+
+    public static get current(): RaitonThread | null {
+        // if (!RaitonThread.instance) throw new Throwable('Thread not initialized')
+        return RaitonThread.instance;
+    }
+
+    public application: ApplicationInterface | null = null;
+    public runtime: RuntimeAdapterInterface | null = null;
+    public runtimeServer: RuntimeServerInterface | null = null;
+
+    readonly appDir: string;
+
+    constructor(
+        public readonly builder: BuilderInterface,
+        protected _options: ThreadOptions = {}
+    ) {
+        this.appDir = process.cwd();
+        RaitonThread.instance = this;
+    }
+
+    public restart(): void {
+        process.send?.(EventMessageEnum.RESTART)
+    }
+
+    public async stop(): Promise<void> {
+        await Injection.shutdown();
+        process.exit(0)
+    }
+
+    public async sleep(milliseconds: number): Promise<unknown> {
+        return await ProcessUtility.sleep(milliseconds);
+    }
+
+    public async wait(condition: ThreadWaitCallable): Promise<void> {
+        return await until(condition)
+    }
+
+    protected getNetworkIp(): string | null {
+        const interfaces = os.networkInterfaces();
+        for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name] || []) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    return iface.address;
+                }
+            }
+        }
+        return null;
+    }
+
+    public setup({application, runtime}: ThreadSetupOptions): this {
+        const defaultRuntime = typeof Bun !== 'undefined' ? RuntimeType.Bun : RuntimeType.Node;
+        this.runtime = new Runtime(runtime || defaultRuntime);
+        this.application = application;
+        this.application.use(bodyParserPlugin())
+        return this;
+    }
+
+    async run(): Promise<this> {
+
+        if (!this.application)
+            throw new Throwable('Application not defined');
+
+        if (!this.runtime)
+            throw new Throwable('Runtime not defined');
+
+        process.on('SIGINT', async () => {
+            await this.stop();
+        });
+
+        process.on('SIGTERM', async () => {
+            await this.stop();
+        });
+
+        const port = this.application.config.port || 5712;
+        const hostname = this.application.config.hostname || '0.0.0.0';
+        const displayHostname = (hostname === '0.0.0.0') ? (this.getNetworkIp() || 'localhost') : hostname;
+        const prefix = this.application.config.prefix
+
+        this.runtimeServer = this.runtime.createServer(this.application.handle.bind(this.application))
+
+        await this.runtimeServer.listen(port, hostname)
+        if (this.builder.source) await ControllerBuilder.scan(this.builder.source)
+
+        Logger.log(LBadge.info('Server Started'), `http://${displayHostname}:${port}${prefix ?? ''}`)
+        return this;
+    }
+}

package/source/env.d.ts

@@ -0,0 +1,3 @@
+declare interface IGlobalGrafts{
+
+}

package/source/requirements.ts

@@ -0,0 +1,27 @@
+import dotenv from "dotenv";
+import path from "node:path";
+import {EventBus, EventBusEnum} from "@protorians/events-bus";
+
+dotenv.config({
+    path: path.join(process.cwd(), '.env'),
+    debug: false,
+    quiet: true,
+});
+
+// @ts-ignore
+process.env.RAITON_NATURAL_MODE = !!process[Symbol.for("ts-node.register.instance")];
+
+
+/**
+ * Process Events caching
+ */
+process.on('beforeExit', (code) => EventBus.dispatch(EventBusEnum.SERVER_SHUTDOWN, {code}));
+// process.on('exit', (code) => EventBus.dispatch(EventBusEnum.SYSTEM_SERVER_SHUTDOWN, {code}));
+process.on('SIGINT', (code) => {
+    EventBus.dispatch(EventBusEnum.SERVER_STOPPED, {code})
+    process.exit(1);
+});
+process.on('SIGTERM', (code) => {
+    EventBus.dispatch(EventBusEnum.SERVER_STOPPED, {code})
+    process.exit(1);
+});

package/source/sdk/artifacts.ts

@@ -0,0 +1,79 @@
+import {Injection} from "@/core/injection";
+import {Logger} from "@protorians/logger";
+import type {IConstructor} from "@/types";
+import {Raiton} from "@/core/raiton";
+import {isArtifact, isControllerArtifact} from "@/sdk/utilities";
+
+export class Artifacts {
+
+    static readonly types: Set<string> = new Set();
+
+    static readonly defaultTypes = [
+        'service',
+        'provider',
+        'type',
+        'repository',
+        'database',
+        'db',
+        'util',
+        'utility',
+        'source',
+        'controller',
+        'middleware',
+        'hook',
+        'event',
+        'listener',
+        'validator',
+        'strategy',
+        'strategy-provider',
+        'strategy-type',
+    ]
+
+    static register(type: string) {
+        this.types.add(type)
+        return this
+    }
+
+    static registerMany(...types: string[]) {
+        for (const type of types) this.register(type)
+        return this;
+    }
+
+    static is(filename: string) {
+        return [...this.types]
+            .map(type => isArtifact(filename, type))
+            .some(Boolean)
+    }
+
+    static reload(modulo: any, filename?: string) {
+
+        if (Raiton.thread?.builder.options.development === false)
+            return Logger.warn(
+                'Artifact reload is only available in development mode'
+            )
+
+        for (const mod of Object.values(modulo)) {
+            const name = (mod && typeof mod === 'object' && 'name' in mod) ? mod.name : (
+                typeof mod === 'function' ? mod.name ?? mod.constructor.name : undefined
+            );
+
+            if (typeof name === 'string' && Injection.has(name)) {
+                if (filename) Injection.registerArtifactPath(name, filename);
+                Injection.updateConstruct(name, mod as IConstructor)
+
+                const dependents = Injection.getDependents(name);
+                for (const dependent of dependents) {
+                    const dependentPath = Injection.getArtifactPath(dependent);
+                    if (dependentPath && isControllerArtifact(dependentPath)) {
+                        Raiton.signals.dispatch('hmr:controller', {
+                            filename: dependentPath,
+                            timestamp: Date.now(),
+                            version: 1
+                        })
+                    }
+                }
+            }
+        }
+
+    }
+}

package/source/sdk/constants/decorators.constant.ts

@@ -0,0 +1,8 @@
+export const METADATA_KEYS = {
+    CONTROLLERS: Symbol('controller:meta'),
+    ROUTE_PARAMETERS: Symbol('route:meta'),
+    GRAFTS: Symbol('graft:meta'),
+    CONTAINER: Symbol('container:meta'),
+    INJECT_PARAMETERS: Symbol('inject:parameters'),
+    INJECT_PROPERTIES: Symbol('inject:properties'),
+}

package/source/sdk/constants/index.ts

@@ -0,0 +1,2 @@
+export * from "./decorators.constant"
+export * from "./microservices.constant"

package/source/sdk/constants/microservices.constant.ts

@@ -0,0 +1,4 @@
+export const MICROSERVICE_NAME = {
+    INDEX: 'Current:Microservice',
+};
+

package/source/sdk/controllers.ts

@@ -0,0 +1,4 @@
+
+export class DelegateController {
+
+}

package/source/sdk/data-transfer-object.ts

@@ -0,0 +1,15 @@
+import {validate, validateOrReject, ValidationError} from "class-validator";
+import {Logger} from "@protorians/logger";
+
+
+export class DataTransferObject {
+    constructor(initial: Record<string, any>) {
+        for (const [key, value] of Object.entries(initial)) {
+            if (typeof value !== 'function') this[key as keyof typeof this] = value;
+        }
+    }
+
+    async validation(strict: boolean = true): Promise<void | ValidationError[]> {
+        return await ((strict ? validateOrReject : validate)(this))
+    }
+}

package/source/sdk/decorators/access-guard.decorator.ts

@@ -0,0 +1,9 @@
+// import {IAccessGuardDeclaration} from "../../types";
+// import {SYSTEM_DECORATORS_KEYS} from "../constants";
+//
+// export function AccessGuard(declaration: IAccessGuardDeclaration){
+//     return (target: any, methodKey: any)=> {
+//         const current: IAccessGuardDeclaration = {...(Reflect.getMetadata(SYSTEM_DECORATORS_KEYS.ACCESS_GUARD, target.constructor, methodKey) || {}), ...declaration};
+//         Reflect.defineMetadata(SYSTEM_DECORATORS_KEYS.ACCESS_GUARD, current, target.constructor, methodKey);
+//     }
+// }

package/source/sdk/decorators/controllable.decorator.ts

@@ -0,0 +1,20 @@
+import {getControllerMetadata} from "@/core/controller";
+import {Injectable} from "@/sdk";
+import {LifetimeEnum} from "@protorians/core";
+import {ControllerDecoratorCallable} from "@/types";
+
+export function Controllable(prefix = '') {
+    return (target: any) => {
+        const name = target.name;
+        Injectable(LifetimeEnum.TRANSIENT, name,)(target)
+
+        const meta = getControllerMetadata(target.prototype || target)
+        meta.prefix = prefix;
+    }
+}
+
+export function createControllerDecorator(callable: ControllerDecoratorCallable) {
+    return (target: any) => {
+        callable(getControllerMetadata(target.prototype || target))
+    }
+}

package/source/sdk/decorators/index.ts

@@ -0,0 +1,5 @@
+export * from "./controllable.decorator"
+export * from "./middleware.decorator"
+export * from "./routable.decorator"
+export * from "./parametrable"
+export * from "./injection.decorator"

package/source/sdk/decorators/injection.decorator.ts

@@ -0,0 +1,46 @@
+import "reflect-metadata";
+import type {IConstructor} from "@/types/contruct";
+import {Injection} from "@/core/injection";
+import {LifetimeEnum} from "@protorians/core";
+import {Logger} from "@protorians/logger";
+import {METADATA_KEYS} from "@/sdk/constants";
+
+
+export function Injectable(lifetime?: LifetimeEnum, name?: string, scope?: any) {
+    return function <T extends IConstructor>(target: T) {
+        const metadata = {
+            name: name || target.name,
+            construct: target,
+            lifetime: lifetime || LifetimeEnum.TRANSIENT,
+            scope
+        };
+        Reflect.defineMetadata(METADATA_KEYS.CONTAINER, metadata, target);
+        Injection.registry(
+            metadata.name,
+            target,
+            metadata.lifetime,
+            scope
+        );
+    };
+}
+
+export function Inject(token?: any) {
+    return function (target: any, propertyKey: string | symbol | undefined, parameterIndex?: number) {
+        if (parameterIndex !== undefined) {
+            const parameters = Reflect.getMetadata(METADATA_KEYS.INJECT_PARAMETERS, target) || [];
+            parameters[parameterIndex] = token || true;
+            Reflect.defineMetadata(METADATA_KEYS.INJECT_PARAMETERS, parameters, target);
+        } else if (propertyKey !== undefined) {
+            const properties = Reflect.getMetadata(METADATA_KEYS.INJECT_PROPERTIES, target.constructor) || new Map();
+            const type = token || Reflect.getMetadata('design:type', target, propertyKey);
+
+            if (type === undefined || type === Object) {
+                Logger.warn(`Injection: impossible de déterminer le type pour la propriété "${String(propertyKey)}" de ${target.constructor.name}. Assurez-vous d'utiliser un token ou que le type est une classe.`);
+            }
+
+            properties.set(propertyKey, type);
+            Reflect.defineMetadata(METADATA_KEYS.INJECT_PROPERTIES, properties, target.constructor);
+        }
+        return target;
+    };
+}

package/source/sdk/decorators/middleware.decorator.ts

@@ -0,0 +1,15 @@
+import {MiddlewareCallable} from "@/types";
+import {getControllerMetadata} from "@/core";
+
+
+export function Middleware(middleware: MiddlewareCallable) {
+    return (target: any, propertyKey?: string) => {
+        const meta = getControllerMetadata(target.prototype || target)
+        const segment = propertyKey ? propertyKey : '@'
+        meta.middlewares[segment] = [...(meta.middlewares[segment] || []), middleware];
+    }
+}
+
+export function createMiddlewareDecoration(middleware: MiddlewareCallable) {
+    return Middleware(middleware);
+}

package/source/sdk/decorators/parametrable.ts

@@ -0,0 +1,28 @@
+import "reflect-metadata";
+import type {Context, ParamMetaInterface} from "@/types";
+import {METADATA_KEYS, Parametrable} from "@/sdk";
+
+function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
+    return (key?: string) => {
+        return (target: any, propertyKey: string, index: number) => {
+            const params = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, target.constructor) || {}
+            const metatypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+            const metatype = metatypes ? metatypes[index] : undefined;
+
+            if (!params[propertyKey]) {
+                params[propertyKey] = []
+            }
+            params[propertyKey].push({index, type, key, callable, metatype})
+            Reflect.defineMetadata(METADATA_KEYS.ROUTE_PARAMETERS, params, target.constructor)
+        }
+    }
+}
+
+export const Query = createRouteParametrableDecorator(Parametrable.QUERY)
+export const Param = createRouteParametrableDecorator(Parametrable.PARAM)
+export const Body = createRouteParametrableDecorator(Parametrable.BODY)
+export const UploadedFile = createRouteParametrableDecorator(Parametrable.UPLOAD_FILE)
+export const Headers = createRouteParametrableDecorator(Parametrable.HEADER)
+export const Req = createRouteParametrableDecorator(Parametrable.REQ)
+export const Reply = createRouteParametrableDecorator(Parametrable.REPLY)
+

package/source/sdk/decorators/routable.decorator.ts

@@ -0,0 +1,45 @@
+import {getControllerMetadata} from "@/core";
+import {HttpMethod} from "@/sdk";
+import {ControllerMetaInterface, RouteDecoratorCallable, RouteMetaInterface} from "@/types";
+
+
+function stabilizeRoute(meta: ControllerMetaInterface, {path, method, propertyKey}: Partial<RouteMetaInterface>) {
+    return {
+        ...meta.routes.filter(route => (route.path === path && route.method === method) || (route.propertyKey === propertyKey))[0] || {},
+        method,
+        path,
+        propertyKey,
+    } as RouteMetaInterface;
+}
+
+export function createRoutableDecorator(method: HttpMethod) {
+    return (path = '') =>
+        (target: any, propertyKey: string) => {
+            const meta: ControllerMetaInterface = getControllerMetadata(target);
+            const route = stabilizeRoute(meta, {
+                method,
+                path,
+                propertyKey,
+            });
+            meta.routes.push(route)
+        }
+}
+
+export function createRouteDecorator(callable: RouteDecoratorCallable) {
+    return (target: any, propertyKey: string) => {
+        const controller: ControllerMetaInterface = getControllerMetadata(target);
+        const route: RouteMetaInterface = stabilizeRoute(controller, {propertyKey})
+        const index = controller.routes.findIndex(route => route.propertyKey === propertyKey)
+
+        callable({controller, route, index})
+    }
+}
+
+export const Get = createRoutableDecorator(HttpMethod.GET)
+export const Post = createRoutableDecorator(HttpMethod.POST)
+export const Put = createRoutableDecorator(HttpMethod.PUT)
+export const Patch = createRoutableDecorator(HttpMethod.PATCH)
+export const Options = createRoutableDecorator(HttpMethod.OPTIONS)
+export const Trace = createRoutableDecorator(HttpMethod.TRACE)
+export const Delete = createRoutableDecorator(HttpMethod.DELETE)
+export const Head = createRoutableDecorator(HttpMethod.HEAD)

package/source/sdk/encryption.ts

@@ -0,0 +1,157 @@
+import crypto from "node:crypto";
+import argon2, {Options} from "argon2";
+import {HashAlgoEnum, PasswordAlgoEnum} from "./enums";
+import bcrypt from "bcrypt";
+import {IDerivationOptions, IEncryptionResult, IScryptOptions} from "@/types";
+
+export class Encryption {
+    static get algos() {
+        return HashAlgoEnum;
+    }
+
+    static randomAlgo(algo?: PasswordAlgoEnum[] | HashAlgoEnum[]) {
+        const algos = algo ?? Object.values(this.algos);
+        return algos[Math.floor(Math.random() * Object.values(algos).length)];
+    }
+
+    constructor(public readonly algo: HashAlgoEnum | PasswordAlgoEnum) {
+        if (![...Object.values(HashAlgoEnum), ...Object.values(PasswordAlgoEnum)].includes(this.algo)) {
+            throw new Error(`Invalid hash algorithm: ${this.algo}`);
+        }
+    }
+
+    async compare(value: string, hash: string): Promise<boolean> {
+        return this.make(value).then(result => result === hash);
+    }
+
+    async make(value: string, options?: IDerivationOptions | IScryptOptions): Promise<IEncryptionResult> {
+        if (!value) {
+            throw new Error('Value cannot be empty');
+        }
+
+        switch (this.algo) {
+            case HashAlgoEnum.SHA256:
+                return this.sha256(value);
+            case HashAlgoEnum.SHA512:
+                return this.sha512(value);
+            case HashAlgoEnum.MD5:
+                return this.md5(value);
+            case HashAlgoEnum.RIPEMD160:
+                return this.ripemd160(value);
+            case HashAlgoEnum.BLAKE2B:
+                return this.blake2b(value);
+            case HashAlgoEnum.SHA3_256:
+                return this.sha3_256(value);
+            case HashAlgoEnum.SHA3_512:
+                return this.sha3_512(value);
+            case HashAlgoEnum.PBKDF2:
+                return this.pbkdf2(value, options as IDerivationOptions | undefined);
+            case HashAlgoEnum.SCRYPT:
+                return this.scrypt(value, options as IScryptOptions | undefined);
+            case HashAlgoEnum.ARGON2ID:
+            case HashAlgoEnum.BCRYPT:
+                return this.password(value);
+            default:
+                throw new Error(`Unsupported algorithm: ${this.algo}`);
+        }
+    }
+
+    protected sha256(value: string): IEncryptionResult {
+        return crypto.createHash("sha256").update(value).digest("hex");
+    }
+
+    protected sha512(value: string): IEncryptionResult {
+        return crypto.createHash("sha512").update(value).digest("hex");
+    }
+
+    protected md5(value: string): IEncryptionResult {
+        return crypto.createHash("md5").update(value).digest("hex");
+    }
+
+    protected ripemd160(value: string): IEncryptionResult {
+        return crypto.createHash("ripemd160").update(value).digest("hex");
+    }
+
+    protected blake2b(value: string): IEncryptionResult {
+        return crypto.createHash("blake2b512").update(value).digest("hex");
+    }
+
+    protected sha3_256(value: string): IEncryptionResult {
+        return crypto.createHash("sha3-256").update(value).digest("hex");
+    }
+
+    protected sha3_512(value: string): IEncryptionResult {
+        return crypto.createHash("sha3-512").update(value).digest("hex");
+    }
+
+    protected pbkdf2(value: string, options?: IDerivationOptions): IEncryptionResult {
+        const {salt, iterations, keylen, digest} = options || {};
+        const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
+        const usedIterations = iterations ?? 100_000;
+        const usedKeylen = keylen ?? 64;
+        const usedDigest = digest ?? "sha512";
+        const derived = crypto
+            .pbkdf2Sync(value, Buffer.from(usedSalt, "hex"), usedIterations, usedKeylen, usedDigest)
+            .toString("hex");
+        return `pbkdf2$${usedDigest}$${usedIterations}$${usedSalt}$${derived}`;
+    }
+
+    protected scrypt(value: string, options?: IScryptOptions): IEncryptionResult {
+        const {salt, keylen, cost, blockSize, parallelization} = options || {} as IScryptOptions;
+        const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
+        const usedKeylen = keylen ?? 64;
+        const usedCost = cost ?? 16384; // N
+        const usedBlockSize = blockSize ?? 8; // r
+        const usedParallel = parallelization ?? 1; // p
+        const derived = crypto
+            .scryptSync(value, Buffer.from(usedSalt, "hex"), usedKeylen, {
+                N: usedCost,
+                r: usedBlockSize,
+                p: usedParallel,
+                maxmem: 32 * 1024 * 1024,
+            })
+            .toString("hex");
+        return `scrypt$${usedCost}$${usedBlockSize}$${usedParallel}$${usedSalt}$${derived}`;
+    }
+
+    protected unsupported(): never {
+        throw new Error(`${this.algo} not supported without optional dependency`);
+    }
+
+    async password(value: string, options?: (Options & {
+        raw?: boolean
+    }) | (string | number) | undefined): Promise<IEncryptionResult> {
+        switch (this.algo) {
+            case HashAlgoEnum.ARGON2ID: {
+                return await argon2.hash(value, {
+                    ...(typeof options === 'object' ? options : {}),
+                    type: argon2.argon2id
+                });
+            }
+            case HashAlgoEnum.BCRYPT: {
+                try {
+                    const saltRounds = 12;
+                    return await bcrypt.hash(
+                        value,
+                        (typeof options === 'string' || typeof options === 'number') ? options : saltRounds
+                    );
+                } catch (e) {
+                    throw new Error(`BCRYPT not supported without optional dependency "bcrypt"`);
+                }
+            }
+            default:
+                throw new Error(`password() is only available for BCRYPT and ARGON2ID (current: ${this.algo})`);
+        }
+    }
+
+    async checkPassword(hash: string, password: string): Promise<boolean> {
+        switch (this.algo) {
+            case HashAlgoEnum.ARGON2ID:
+                return await argon2.verify(hash, password);
+            case HashAlgoEnum.BCRYPT:
+                return await bcrypt.compare(password, hash);
+        }
+        return false;
+    }
+
+}

package/source/sdk/enums/encrypted.enum.ts

@@ -0,0 +1,23 @@
+export enum HashAlgoEnum {
+    ARGON2ID = 'ARGON2ID',
+    BCRYPT = 'BCRYPT',
+    PBKDF2 = 'PBKDF2',
+    SCRYPT = 'SCRYPT',
+    SHA256 = 'SHA256',
+    SHA512 = 'SHA512',
+    MD5 = 'MD5',
+    RIPEMD160 = 'RIPEMD160',
+    BLAKE2B = 'BLAKE2B',
+    SHA3_256 = 'SHA3_256',
+    SHA3_512 = 'SHA3_512',
+}
+
+export enum CipherAlgoEnum {
+    AES_256_CBC = 'AES-256-CBC',
+}
+
+export enum PasswordAlgoEnum {
+    ARGON2ID = 'argon2id',
+    BCRYPT = 'BCRYPT',
+    SCRYPT = 'SCRYPT',
+}

package/source/sdk/enums/event.message.enum.ts

@@ -0,0 +1,4 @@
+export enum EventMessageEnum {
+    RESTART = ":restart",
+    STOP = ":stop",
+}

package/source/sdk/enums/http-method.enum.ts

@@ -0,0 +1,10 @@
+export enum HttpMethod {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+    PATCH = 'PATCH',
+    OPTIONS = 'OPTIONS',
+    HEAD = 'HEAD',
+    TRACE = 'TRACE',
+}

package/{build/sdk/enums/http-parameters.enum.d.ts → source/sdk/enums/http-parameters.enum.ts}

@@ -1,4 +1,4 @@
-declare enum Parametrable {
+export enum Parametrable {
     PARAM = "param",
     BODY = "body",
     QUERY = "query",
@@ -6,7 +6,5 @@ declare enum Parametrable {
     REQ = "req",
     REPLY = "reply",
     UPLOAD_FILE = "upload",
-    CUSTOM = "custom"
-}
-
-export { Parametrable };
+    CUSTOM = "custom",
+}