@koalarx/nest 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Igor D. Rangel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+<p align="center">
+  <a href="https://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="120" alt="Nest Logo" /></a>
+</p>
+
+<h1 align="center">@koalarx/nest</h1>
+
+<p align="center">Uma abstração <a href="https://nestjs.com" target="_blank">Nest.js</a> para APIs escaláveis.</p>

package/common/backgroud-services/cron-service/cron-job.d.ts

@@ -0,0 +1,15 @@
+import { ILoggingService } from '../../../services/logging/ilogging.service';
+import { IRedLockService } from '../../../services/redlock/ired-lock.service';
+import { RequestResult } from '../../mediator/request-result';
+export type CronJobResponse = RequestResult<Error, null>;
+export declare abstract class CronJob {
+    private readonly redlockService;
+    private readonly loggingService;
+    private readonly loggedUsername;
+    private readonly appName;
+    readonly timeout: number;
+    protected constructor(redlockService: IRedLockService, loggingService: ILoggingService, loggedUsername: string, appName: string, timeInMinutes: number);
+    abstract run(): Promise<void>;
+    protected abstract isActive(): Promise<boolean>;
+    protected start(job: () => Promise<CronJobResponse>): Promise<void>;
+}

package/common/backgroud-services/cron-service/cron-job.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJob = void 0;
+const delay_1 = require("@koalarx/utils/operators/delay");
+class CronJob {
+    redlockService;
+    loggingService;
+    loggedUsername;
+    appName;
+    timeout;
+    constructor(redlockService, loggingService, loggedUsername, appName, timeInMinutes) {
+        this.redlockService = redlockService;
+        this.loggingService = loggingService;
+        this.loggedUsername = loggedUsername;
+        this.appName = appName;
+        this.timeout = timeInMinutes * 60 * 1000;
+    }
+    async start(job) {
+        const name = this.constructor.name;
+        while (true) {
+            if (await this.isActive()) {
+                const ttlSecondsLock = this.timeout / 1000;
+                const acquiredLock = await this.redlockService.acquiredLock(name, ttlSecondsLock);
+                if (acquiredLock) {
+                    const error = await job()
+                        .then((result) => {
+                        if (result.isFailure()) {
+                            return result.value;
+                        }
+                        return null;
+                    })
+                        .catch((error) => error);
+                    if (error) {
+                        this.loggingService.report({
+                            error,
+                            packageName: this.appName,
+                            loggedUsername: this.loggedUsername,
+                        });
+                    }
+                }
+            }
+            await (0, delay_1.klDelay)(this.timeout);
+            await this.redlockService.releaseLock(name);
+        }
+    }
+}
+exports.CronJob = CronJob;

package/common/backgroud-services/event-service/event-class.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class EventClass<TEventJob> {
+    eventJob: TEventJob;
+    ocurredAt: Date;
+    constructor(eventJob: TEventJob);
+}

package/common/backgroud-services/event-service/event-class.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventClass = void 0;
+class EventClass {
+    eventJob;
+    ocurredAt = new Date();
+    constructor(eventJob) {
+        this.eventJob = eventJob;
+    }
+}
+exports.EventClass = EventClass;

package/common/backgroud-services/event-service/event-handler.d.ts

@@ -0,0 +1,5 @@
+import { EventClass } from './event-class';
+export declare abstract class EventHandler<TEventJob> {
+    setupSubscriptions(): void;
+    abstract handleEvent(event: EventClass<TEventJob>): Promise<void>;
+}

package/common/backgroud-services/event-service/event-handler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const event_queue_1 = require("./event-queue");
+class EventHandler {
+    setupSubscriptions() {
+        event_queue_1.EventQueue.register(this.handleEvent.bind(this), this.constructor.name);
+    }
+}
+exports.EventHandler = EventHandler;

package/common/backgroud-services/event-service/event-is-trigger.d.ts

@@ -0,0 +1,3 @@
+export declare class EventIsTrigger {
+    isTrigger(): void;
+}

package/common/backgroud-services/event-service/event-is-trigger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventIsTrigger = void 0;
+class EventIsTrigger {
+    isTrigger() { }
+}
+exports.EventIsTrigger = EventIsTrigger;

package/common/backgroud-services/event-service/event-job.d.ts

@@ -0,0 +1,10 @@
+import { Entity } from '../../../core/database/entity';
+import { IComparable } from '../../../core/utils/interfaces/icomparable';
+import { EventClass } from './event-class';
+import { EventQueue } from './event-queue';
+export declare class EventJob<TEntity extends IComparable> extends Entity<TEntity> {
+    private _eventQueue;
+    get eventQueue(): EventQueue[];
+    clearQueue(): void;
+    addEvent(event: EventClass<EventJob<TEntity>>): void;
+}

package/common/backgroud-services/event-service/event-job.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventJob = void 0;
+const entity_1 = require("../../../core/database/entity");
+const event_queue_1 = require("./event-queue");
+class EventJob extends entity_1.Entity {
+    _eventQueue = [];
+    get eventQueue() {
+        return this._eventQueue;
+    }
+    clearQueue() {
+        this._eventQueue = [];
+    }
+    addEvent(event) {
+        this.eventQueue.push(event);
+        event_queue_1.EventQueue.markAggregateForDispatch(this);
+    }
+}
+exports.EventJob = EventJob;

package/common/backgroud-services/event-service/event-queue.d.ts

@@ -0,0 +1,17 @@
+import { IComparableId } from '../../../core/utils/interfaces/icomparable';
+import { EventJob } from './event-job';
+type EventJobCallback = (event: any) => void;
+export declare class EventQueue {
+    private static handlersMap;
+    private static markedAggregates;
+    static markAggregateForDispatch(aggregate: EventJob<any>): void;
+    static dispatchEventsForAggregate(id: IComparableId): void;
+    static register(callback: EventJobCallback, eventClassName: string): void;
+    static clearHandlers(): void;
+    static clearMarkedAggregates(): void;
+    private static dispatchAggregateEvents;
+    private static removeAggregateFromMarkedDispatchList;
+    private static findMarkedAggregateByID;
+    private static dispatch;
+}
+export {};

package/common/backgroud-services/event-service/event-queue.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueue = void 0;
+class EventQueue {
+    static handlersMap = {};
+    static markedAggregates = [];
+    static markAggregateForDispatch(aggregate) {
+        const aggregateFound = !!this.findMarkedAggregateByID(aggregate.id);
+        if (!aggregateFound) {
+            this.markedAggregates.push(aggregate);
+        }
+    }
+    static dispatchEventsForAggregate(id) {
+        const aggregate = this.findMarkedAggregateByID(id);
+        if (aggregate) {
+            this.dispatchAggregateEvents(aggregate);
+            aggregate.clearQueue();
+            this.removeAggregateFromMarkedDispatchList(aggregate);
+        }
+    }
+    static register(callback, eventClassName) {
+        const wasEventRegisteredBefore = eventClassName in this.handlersMap;
+        if (!wasEventRegisteredBefore) {
+            this.handlersMap[eventClassName] = [];
+        }
+        this.handlersMap[eventClassName].push(callback);
+    }
+    static clearHandlers() {
+        this.handlersMap = {};
+    }
+    static clearMarkedAggregates() {
+        this.markedAggregates = [];
+    }
+    static dispatchAggregateEvents(aggregate) {
+        aggregate.eventQueue.forEach((event) => this.dispatch(event));
+    }
+    static removeAggregateFromMarkedDispatchList(aggregate) {
+        const index = this.markedAggregates.findIndex((a) => a.equals(aggregate));
+        this.markedAggregates.splice(index, 1);
+    }
+    static findMarkedAggregateByID(id) {
+        return this.markedAggregates.find((aggregate) => aggregate.id === id);
+    }
+    static dispatch(event) {
+        const eventClassName = event.constructor.name;
+        const isEventRegistered = eventClassName in this.handlersMap;
+        if (isEventRegistered) {
+            const handlers = this.handlersMap[eventClassName];
+            for (const handler of handlers) {
+                handler(event);
+            }
+        }
+    }
+}
+exports.EventQueue = EventQueue;

package/common/controllers/base.controller.d.ts

@@ -0,0 +1,4 @@
+import { Response as HttpResponse } from 'express';
+export declare abstract class IController<Request, Response, Params = any> {
+    abstract handle(request: Request, params?: Params, response?: HttpResponse): Promise<Response>;
+}

package/common/controllers/base.controller.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IController = void 0;
+class IController {
+}
+exports.IController = IController;

package/common/controllers/created-registre-response.base.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class CreatedRegistreResponseBase {
+    id: string;
+}

package/common/controllers/created-registre-response.base.js

@@ -0,0 +1,17 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatedRegistreResponseBase = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class CreatedRegistreResponseBase {
+    id;
+}
+exports.CreatedRegistreResponseBase = CreatedRegistreResponseBase;
+__decorate([
+    (0, swagger_1.ApiProperty)()
+], CreatedRegistreResponseBase.prototype, "id", void 0);

package/common/controllers/list-response.base.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class ListResponseBase<TResponse> {
+    abstract items: Array<TResponse>;
+    count: number;
+}

package/common/controllers/list-response.base.js

@@ -0,0 +1,17 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListResponseBase = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class ListResponseBase {
+    count;
+}
+exports.ListResponseBase = ListResponseBase;
+__decorate([
+    (0, swagger_1.ApiProperty)()
+], ListResponseBase.prototype, "count", void 0);

package/common/controllers/router-config.base.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class RouterConfigBase {
+    private readonly _tag;
+    private readonly _group;
+    protected constructor(_tag: string, _group: string);
+    get group(): string;
+    get tag(): string;
+}

package/common/controllers/router-config.base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterConfigBase = void 0;
+class RouterConfigBase {
+    _tag;
+    _group;
+    constructor(_tag, _group) {
+        this._tag = _tag;
+        this._group = _group;
+    }
+    get group() {
+        return this._group;
+    }
+    get tag() {
+        return this._tag;
+    }
+}
+exports.RouterConfigBase = RouterConfigBase;

package/common/controllers/schemas/document-number.schema.d.ts

@@ -0,0 +1 @@
+export declare function documentNumberSchema(value: string): boolean;

package/common/controllers/schemas/document-number.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentNumberSchema = void 0;
+const string_1 = require("@koalarx/utils/operators/string");
+function documentNumberSchema(value) {
+    if (value !== '' && value !== 'undefined' && value !== 'null') {
+        if (value.includes('.')) {
+            if (value.length === 14) {
+                return (0, string_1.validateCpf)(value);
+            }
+            else if (value.length === 18) {
+                return (0, string_1.validateCnpj)(value);
+            }
+        }
+        else {
+            if (value.length === 11) {
+                return (0, string_1.validateCpf)(value);
+            }
+            else if (value.length === 14) {
+                return (0, string_1.validateCnpj)(value);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+exports.documentNumberSchema = documentNumberSchema;

package/common/controllers/schemas/email.schema.d.ts

@@ -0,0 +1 @@
+export declare function emailSchema(email?: string, isRequired?: boolean): string | boolean;

package/common/controllers/schemas/email.schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emailSchema = void 0;
+const zod_1 = require("zod");
+function emailSchema(email, isRequired = false) {
+    if (isRequired && !email) {
+        return false;
+    }
+    if (!email) {
+        return true;
+    }
+    return zod_1.z.coerce.string().max(50).email().parse(email);
+}
+exports.emailSchema = emailSchema;

package/common/controllers/schemas/list-query.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const LIST_QUERY_SCHEMA: z.ZodObject<{
+    page: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, number>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    orderBy: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodDefault<z.ZodEnum<["asc", "desc"]>>>;
+}, "strip", z.ZodTypeAny, {
+    page?: number | undefined;
+    limit?: number | undefined;
+    orderBy?: string | undefined;
+    direction?: "asc" | "desc" | undefined;
+}, {
+    page?: number | undefined;
+    limit?: number | undefined;
+    orderBy?: string | undefined;
+    direction?: "asc" | "desc" | undefined;
+}>;

package/common/controllers/schemas/list-query.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_QUERY_SCHEMA = void 0;
+const zod_1 = require("zod");
+const pagination_params_1 = require("../../models/pagination-params");
+exports.LIST_QUERY_SCHEMA = zod_1.z.object({
+    page: zod_1.z.coerce
+        .number()
+        .transform((value) => {
+        if (value) {
+            return value - 1;
+        }
+        return pagination_params_1.QueryFilterParams.page;
+    })
+        .optional(),
+    limit: zod_1.z.coerce.number().default(pagination_params_1.QueryFilterParams.limit).optional(),
+    orderBy: zod_1.z.string().optional(),
+    direction: zod_1.z.enum(['asc', 'desc']).default('asc').optional(),
+});

package/common/controllers/schemas/native-enum.schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+interface NativeEnumInterface<TEnum> {
+    isOptional: (value: string) => TEnum[keyof TEnum] | undefined;
+    isRequired: (value: string) => TEnum[keyof TEnum];
+}
+export declare function nativeEnumSchema<TEnum extends z.EnumLike>(nativeEnum: TEnum): NativeEnumInterface<TEnum>;
+export {};

package/common/controllers/schemas/native-enum.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeEnumSchema = void 0;
+const zod_1 = require("zod");
+function nativeEnumSchema(nativeEnum) {
+    return {
+        isOptional: (value) => {
+            if (value === 'null' || value === '') {
+                return undefined;
+            }
+            return zod_1.z.coerce
+                .number()
+                .transform((value) => {
+                if (value !== undefined) {
+                    return zod_1.z.nativeEnum(nativeEnum).parse(value);
+                }
+                return undefined;
+            })
+                .parse(value);
+        },
+        isRequired: (value) => {
+            return zod_1.z.coerce
+                .number()
+                .transform((value) => zod_1.z.nativeEnum(nativeEnum).parse(value))
+                .parse(value);
+        },
+    };
+}
+exports.nativeEnumSchema = nativeEnumSchema;

package/common/errors/bad-request.error.d.ts

@@ -0,0 +1,4 @@
+import { UseCaseError } from './use-case-error';
+export declare class BadRequestError extends Error implements UseCaseError {
+    constructor(message?: string);
+}

package/common/errors/bad-request.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+class BadRequestError extends Error {
+    constructor(message) {
+        super(message ?? 'Bad Request');
+    }
+}
+exports.BadRequestError = BadRequestError;

package/common/errors/conflict.error.d.ts

@@ -0,0 +1,3 @@
+export declare class ConflictError extends Error {
+    constructor(identifier: string);
+}

package/common/errors/conflict.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = void 0;
+class ConflictError extends Error {
+    constructor(identifier) {
+        super(`O registro ${identifier} já existe.`);
+    }
+}
+exports.ConflictError = ConflictError;

package/common/errors/no-content.error.d.ts

@@ -0,0 +1,4 @@
+import { UseCaseError } from './use-case-error';
+export declare class NoContentError extends Error implements UseCaseError {
+    constructor(message?: string);
+}

package/common/errors/no-content.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoContentError = void 0;
+class NoContentError extends Error {
+    constructor(message) {
+        super(message ?? 'No Content');
+    }
+}
+exports.NoContentError = NoContentError;

package/common/errors/not-allowed.error.d.ts

@@ -0,0 +1,4 @@
+import { UseCaseError } from './use-case-error';
+export declare class NotAllowedError extends Error implements UseCaseError {
+    constructor(message?: string);
+}

package/common/errors/not-allowed.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowedError = void 0;
+class NotAllowedError extends Error {
+    constructor(message) {
+        super(message ?? 'Você não tem permissão para utilizar esse recurso.');
+    }
+}
+exports.NotAllowedError = NotAllowedError;

package/common/errors/resource-not-found.error.d.ts

@@ -0,0 +1,4 @@
+import { UseCaseError } from './use-case-error';
+export declare class ResourceNotFoundError extends Error implements UseCaseError {
+    constructor(name?: string);
+}

package/common/errors/resource-not-found.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceNotFoundError = void 0;
+class ResourceNotFoundError extends Error {
+    constructor(name = 'Recurso') {
+        super(`${name} não encontrado(a).`);
+    }
+}
+exports.ResourceNotFoundError = ResourceNotFoundError;

package/common/errors/use-case-error.d.ts

@@ -0,0 +1,3 @@
+export interface UseCaseError {
+    message: string;
+}

package/common/errors/use-case-error.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/common/errors/user-already-exist.error.d.ts

@@ -0,0 +1,3 @@
+export declare class UserAlreadyExist extends Error {
+    constructor(identifier: string);
+}

package/common/errors/user-already-exist.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAlreadyExist = void 0;
+class UserAlreadyExist extends Error {
+    constructor(identifier) {
+        super(`User ${identifier} already exists`);
+    }
+}
+exports.UserAlreadyExist = UserAlreadyExist;

package/common/errors/wrong-credentials.error.d.ts

@@ -0,0 +1,3 @@
+export declare class WrongCredentialsError extends Error {
+    constructor();
+}

package/common/errors/wrong-credentials.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongCredentialsError = void 0;
+class WrongCredentialsError extends Error {
+    constructor() {
+        super('Credentials are not valid');
+    }
+}
+exports.WrongCredentialsError = WrongCredentialsError;

package/common/mediator/request-handler.base.d.ts

@@ -0,0 +1,4 @@
+import { RequestResult } from '../../common/mediator/request-result';
+export declare abstract class RequestHandlerBase<TRequest, TResponse extends RequestResult<Error, any>> {
+    abstract handle(req: TRequest): Promise<TResponse>;
+}

package/common/mediator/request-handler.base.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandlerBase = void 0;
+class RequestHandlerBase {
+}
+exports.RequestHandlerBase = RequestHandlerBase;

package/common/mediator/request-result.d.ts

@@ -0,0 +1,15 @@
+export declare class Failure<L, R> {
+    readonly value: L;
+    constructor(value: L);
+    isFailure(): this is Failure<L, R>;
+    isOk(): this is Ok<L, R>;
+}
+export declare class Ok<L, R> {
+    readonly value: R;
+    constructor(value: R);
+    isFailure(): this is Failure<L, R>;
+    isOk(): this is Ok<L, R>;
+}
+export type RequestResult<L, R> = Failure<L, R> | Ok<L, R>;
+export declare const failure: <L, R>(value: L) => RequestResult<L, R>;
+export declare const ok: <L, R>(value: R) => RequestResult<L, R>;