@rockster/core 0.0.1

package/controllers/decorators/http-methods/post.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Post = Post;
+const common_1 = require("@rockster/common");
+const class_injector_1 = require("@rockster/class-injector");
+function Post(path) {
+    return (target, propertyKey) => {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.path = path;
+        property.httpMethod = common_1.HttpMethod.post;
+        property.isRestful = true;
+        (0, class_injector_1.markExecutable)(target, propertyKey);
+    };
+}

package/controllers/decorators/http-methods/put.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Put(path?: string): PropertyDecorator;

package/controllers/decorators/http-methods/put.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Put = Put;
+const common_1 = require("@rockster/common");
+const class_injector_1 = require("@rockster/class-injector");
+function Put(path) {
+    return (target, propertyKey) => {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.path = path;
+        property.httpMethod = common_1.HttpMethod.put;
+        property.isRestful = true;
+        (0, class_injector_1.markExecutable)(target, propertyKey);
+    };
+}

package/controllers/decorators/http-methods/response-type.decorator.d.ts

@@ -0,0 +1,6 @@
+import { GetTypeCallback } from "@rockster/common";
+export type ResponseTypeOptions = {
+    array?: boolean;
+    expose?: string[];
+};
+export declare function ResponseType(type: GetTypeCallback | 'json', options?: ResponseTypeOptions): PropertyDecorator;

package/controllers/decorators/http-methods/response-type.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseType = ResponseType;
+function ResponseType(type, options) {
+    return (target, propertyKey) => {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.hasResponse = true;
+        property.isResponseArray = options?.array;
+        property.responseType = typeof type === 'function'
+            ? 'typed'
+            : 'json';
+        property.exposeGroups = options?.expose;
+        property.getResponseType = property.responseType === 'typed'
+            ? type
+            : undefined;
+    };
+}

package/controllers/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './actions';
+export * from './http-methods';
+export * from './request-context.decorator';
+export * from './controller.decorator';
+export * from './no-auth.decorator';

package/controllers/decorators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./actions"), exports);
+__exportStar(require("./http-methods"), exports);
+__exportStar(require("./request-context.decorator"), exports);
+__exportStar(require("./controller.decorator"), exports);
+__exportStar(require("./no-auth.decorator"), exports);

package/controllers/decorators/no-auth.decorator.d.ts

@@ -0,0 +1 @@
+export declare function NoAuth(): PropertyDecorator;

package/controllers/decorators/no-auth.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoAuth = NoAuth;
+function NoAuth() {
+    return (target, propertyKey) => {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.public = true;
+    };
+}

package/controllers/decorators/request-context.decorator.d.ts

@@ -0,0 +1 @@
+export declare const RequestContext: () => (target: any, propertyKey: string, index: number) => void;

package/controllers/decorators/request-context.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContext = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const constants_1 = require("../constants");
+const RequestContext = () => {
+    return (target, propertyKey, index) => {
+        (0, class_injector_1.Inject)(constants_1.REQUEST_CONTEXT_KEY)(target, propertyKey, index);
+    };
+};
+exports.RequestContext = RequestContext;

package/controllers/decorators/session.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Session(): ParameterDecorator;

package/controllers/decorators/session.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = Session;
+const class_injector_1 = require("@rockster/class-injector");
+const constants_1 = require("../constants");
+function Session() {
+    return (target, propertyKey, parameterIndex) => {
+        (0, class_injector_1.Inject)(constants_1.SESSION_KEY)(target, propertyKey, parameterIndex);
+    };
+}

package/controllers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorators';
+export * from './controller.controller';

package/controllers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./controller.controller"), exports);

package/controllers/interfaces/action-options.d.ts

@@ -0,0 +1,31 @@
+import { GetTypeCallback } from "../../common";
+export type ActionOptions = {
+    /**
+     * Custom name for action
+     */
+    name?: string;
+    /**
+     * Default: false. Define the action is public and is not necessary to pass and userId
+     */
+    public?: boolean;
+    /**
+     * Description for docs
+     */
+    description?: string;
+    /**
+     * Define response
+     */
+    response?: GetTypeCallback | boolean;
+    /**
+     * Define response is array of type
+     */
+    isArray?: boolean;
+    /**
+     * Groups to expose response content
+     */
+    expose?: string[];
+    /**
+     * Groups to validate request content
+     */
+    validate?: string[];
+};

package/controllers/interfaces/action-options.js

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

package/controllers/interfaces/content-options.d.ts

@@ -0,0 +1,5 @@
+import { GetOnlyData } from "./get-only-data";
+export type ContentOptions = {
+    onlyData?: boolean | GetOnlyData;
+    strict?: boolean;
+};

package/controllers/interfaces/content-options.js

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

package/controllers/interfaces/controller-object.d.ts

@@ -0,0 +1,7 @@
+import { ObjectType } from "../../common";
+import { IObject } from "../../core";
+export interface IControllerObject extends IObject {
+    type: ObjectType.controller;
+    alias: string;
+    path: string;
+}

package/controllers/interfaces/controller-object.js

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

package/controllers/interfaces/controller-options.d.ts

@@ -0,0 +1,4 @@
+export type ControllerOptions = {
+    alias?: string;
+    path?: string;
+};

package/controllers/interfaces/controller-options.js

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

package/controllers/interfaces/controller-property.d.ts

@@ -0,0 +1,34 @@
+import { HttpMethod, HttpStatus, Instantiable } from "@rockster/common";
+import { ContentOptions } from "./content-options";
+import { IProperty } from "../../core";
+import { PropertyType } from "../../common/interfaces/enum/property-type";
+import { GetTypeCallback } from "../../common/interfaces/get-type-callback";
+export interface IControllerProperty extends IProperty {
+    type: PropertyType.request;
+    name?: string;
+    public?: boolean;
+    data?: Instantiable;
+    description?: string;
+    hasResponse?: boolean;
+    responseType?: 'json' | 'typed';
+    getResponseType?: GetTypeCallback;
+    customResponse?: boolean;
+    content?: ContentOptions;
+    actionType?: string;
+    path?: string;
+    isRestful?: boolean;
+    httpMethod?: HttpMethod;
+    isResponseArray?: boolean;
+    fromQuery?: Instantiable;
+    fromQueryFields?: string[];
+    fromBody?: Instantiable;
+    fromBodyFields?: string[];
+    fromHeaders?: Instantiable;
+    fromHeadersFields?: string[];
+    fromParams?: Instantiable;
+    fromParamsFields?: string[];
+    responseHttpStatus?: HttpStatus;
+    fullPath?: string;
+    exposeGroups?: string[];
+    validateGroups?: string[];
+}

package/controllers/interfaces/controller-property.js

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

package/controllers/interfaces/enum/index.d.ts

@@ -0,0 +1 @@
+export * from './request-interceptor';

package/controllers/interfaces/enum/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./request-interceptor"), exports);

package/controllers/interfaces/enum/request-interceptor.d.ts

@@ -0,0 +1,3 @@
+export declare const requestInterceptor: {
+    onBeforeValidation: string;
+};

package/controllers/interfaces/enum/request-interceptor.js

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

package/controllers/interfaces/get-only-data.d.ts

@@ -0,0 +1,3 @@
+export type GetOnlyData = {
+    (value: any): boolean;
+};

package/controllers/interfaces/get-only-data.js

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

package/controllers/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from './enum';
+export * from './action-options';
+export * from './content-options';
+export * from './get-only-data';
+export * from './on-before-validation-data';
+export * from './controller-object';
+export * from './controller-options';
+export * from './controller-property';
+export * from './response-options';

package/controllers/interfaces/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enum"), exports);
+__exportStar(require("./action-options"), exports);
+__exportStar(require("./content-options"), exports);
+__exportStar(require("./get-only-data"), exports);
+__exportStar(require("./on-before-validation-data"), exports);
+__exportStar(require("./controller-object"), exports);
+__exportStar(require("./controller-options"), exports);
+__exportStar(require("./controller-property"), exports);
+__exportStar(require("./response-options"), exports);

package/controllers/interfaces/on-before-validation-data.d.ts

@@ -0,0 +1,4 @@
+import { ValidateOptions } from "@rockster/class-pipe";
+export interface OnBeforeValidationData {
+    options: ValidateOptions;
+}

package/controllers/interfaces/on-before-validation-data.js

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

package/controllers/interfaces/response-options.d.ts

@@ -0,0 +1,5 @@
+import { GetTypeCallback } from "../../common";
+export interface IResponseOptions {
+    description?: string;
+    type?: GetTypeCallback;
+}

package/controllers/interfaces/response-options.js

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

package/controllers/services/default-action-builder.d.ts

@@ -0,0 +1,14 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { IControllerObject, IControllerProperty } from "../interfaces";
+import { ExecuteInterceptorHandle, IActionDocs, PendingAction, IRequestContext } from "../../core";
+import { ExecutorData } from "@rockster/class-injector/interfaces";
+import { Dictionary } from "@rockster/common";
+export declare class DefaultActionBuilder {
+    protected beforeInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    protected afterInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    protected beforeValidationInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    create(object: ObjectNote<IControllerObject>): Promise<void>;
+    protected createDocs(object: ObjectNote<IControllerObject>, property: PropertyNote<IControllerProperty>, name: string, path: string, isSecure: boolean): IActionDocs;
+    protected execute(pending: PendingAction, context: IRequestContext, data: ExecutorData, property: PropertyNote<IControllerProperty>): Promise<void>;
+    protected onBefore(pending: PendingAction, context: IRequestContext, property: PropertyNote<IControllerProperty>): Promise<void>;
+}

package/controllers/services/default-action-builder.js

@@ -0,0 +1,166 @@
+"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.DefaultActionBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const interfaces_1 = require("../interfaces");
+const core_1 = require("../../core");
+const class_pipe_1 = require("@rockster/class-pipe");
+const constants_1 = require("../constants");
+const executed_response_1 = require("../../common/models/executed-response");
+const request_status_1 = require("../../common/interfaces/enum/request-status");
+const web_socket_1 = require("../../web-socket");
+let DefaultActionBuilder = class DefaultActionBuilder {
+    constructor() {
+        this.beforeInterceptors = {};
+        this.afterInterceptors = {};
+        this.beforeValidationInterceptors = {};
+    }
+    async create(object) {
+        const data = await (0, class_injector_1.createExecutors)(object.objectClass);
+        const properties = core
+            .storage
+            .getProperties(object.objectClass)
+            .filter((property) => {
+            return property.actionType === constants_1.ACTION_TYPE;
+        });
+        for (const property of properties) {
+            const isSecure = !property.public;
+            const name = property.name || property.propertyKey;
+            const path = (0, core_1.getActionPath)(object.alias, name);
+            this.beforeInterceptors[path] =
+                (0, core_1.createExecuteInterceptors)([core_1.commonInterceptor.onBeforeExecute], object, property);
+            this.afterInterceptors[path] =
+                (0, core_1.createExecuteInterceptors)([core_1.commonInterceptor.onAfterExecute], object, property);
+            this.beforeValidationInterceptors[path] =
+                (0, core_1.createExecuteInterceptors)([interfaces_1.requestInterceptor.onBeforeValidation], object, property);
+            (0, core_1.createAction)({
+                objectClass: object.objectClass,
+                path: path,
+                name: name,
+                secure: isSecure,
+                execute: async (action, context) => {
+                    return this
+                        .execute(action, context, data.executors[name], property);
+                },
+                onBefore: async (action, context) => {
+                    return this
+                        .onBefore(action, context, property);
+                },
+                docs: this
+                    .createDocs(object, property, name, path, isSecure)
+            });
+        }
+    }
+    createDocs(object, property, name, path, isSecure) {
+        const Payload = property.data;
+        const Response = property.getResponseType
+            ? property.getResponseType()
+            : null;
+        if (Payload)
+            core.models.pushIfNotExists(Payload);
+        if (Response)
+            core.models.pushIfNotExists(Response);
+        return {
+            alias: object.alias,
+            name: name,
+            path: path,
+            description: property.description,
+            isSecure: isSecure,
+            payload: Payload?.name,
+            isResponseArray: property.isResponseArray,
+            response: Response ? Response.name
+                : property.hasResponse ? 'Any'
+                    : undefined,
+        };
+    }
+    async execute(pending, context, data, property) {
+        await this.beforeInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        });
+        const response = await data.handle({
+            [constants_1.CONTENT_KEY]: pending.annotations[constants_1.CONTENT_KEY],
+            [constants_1.REQUEST_CONTEXT_KEY]: context,
+            [web_socket_1.WS_CLIENT_KEY]: context.wsClient
+        });
+        if (property.getResponseType) {
+            const type = property.getResponseType();
+            if (!response) {
+                context.response[pending.property] = null;
+            }
+            else {
+                context.response[pending.property] = property.isResponseArray
+                    ? await Promise.all(response.map((itemResponse) => {
+                        return (0, class_pipe_1.transform)({
+                            target: type,
+                            values: itemResponse,
+                            groups: property.exposeGroups
+                        });
+                    }))
+                    : await (0, class_pipe_1.transform)({
+                        target: type,
+                        values: response
+                    });
+            }
+        }
+        else if (property.hasResponse && response) {
+            context.response[pending.property] = response;
+        }
+        else {
+            context.response[pending.property] = await (0, class_pipe_1.transform)({
+                target: executed_response_1.ExecutedResponse,
+                values: { status: request_status_1.RequestStatus.executed }
+            });
+        }
+        await this.afterInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        }, true);
+    }
+    async onBefore(pending, context, property) {
+        if (property.data) {
+            const sanitized = {};
+            const payload = context
+                .request[pending.requestRef];
+            const onlyData = property
+                .content
+                .onlyData;
+            const options = {
+                groups: property.validateGroups,
+                onlyData: typeof onlyData === 'function'
+                    ? onlyData(payload)
+                    : (onlyData || false)
+            };
+            await this
+                .beforeValidationInterceptors[pending.path]({
+                action: pending,
+                context: context,
+                extra: { options },
+                property: property
+            });
+            const errors = await (0, class_pipe_1.validate)(property.data, payload, sanitized, options);
+            if (errors) {
+                errors.target = pending.requestRef;
+                throw errors;
+            }
+            const strict = property
+                .content
+                .strict;
+            pending.annotations[constants_1.CONTENT_KEY] = strict
+                ? sanitized
+                : payload;
+        }
+    }
+};
+exports.DefaultActionBuilder = DefaultActionBuilder;
+exports.DefaultActionBuilder = DefaultActionBuilder = __decorate([
+    (0, class_injector_1.Injectable)()
+], DefaultActionBuilder);

package/controllers/services/restful-action-builder.d.ts

@@ -0,0 +1,11 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { IControllerObject } from "../interfaces/controller-object";
+import { IControllerProperty } from "../interfaces/controller-property";
+import { HttpController } from "../../http/http.controller";
+import { Dictionary, Instantiable } from "@rockster/common";
+export declare class RestfulActionBuilder {
+    private readonly httpController;
+    constructor(httpController: HttpController);
+    create(object: ObjectNote<IControllerObject>): Promise<void>;
+    protected buildPartData(property: PropertyNote<IControllerProperty>, targetName: string, targetKey: string, target: Instantiable, targetFields: string[], initialData: Dictionary<any>, values?: any): Promise<void>;
+}