@rockster/core 0.0.1

package/query/functions/load-properties.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProperties = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+const object_type_1 = require("../../common/interfaces/enum/object-type");
+const get_id_property_1 = require("../../database/functions/get-id-property");
+const loadProperties = ({ type, target, alias, entityAlias, properties, parent, paths, relation, fullPath = '', secure, initializedObjects = [], rootEntity, rootFullPath }) => {
+    // fullPath agora representa o caminho global (root até aqui)
+    const currentPath = fullPath ? `${fullPath}.${alias}` : alias;
+    ;
+    const initializedObjectKey = `${currentPath}:${target.name}`;
+    if (initializedObjects.includes(initializedObjectKey))
+        return;
+    initializedObjects.push(initializedObjectKey);
+    const targetProperties = (0, class_pipe_1.getExposeProperties)(target);
+    targetProperties
+        .filter((property) => {
+        if (property.subtype) {
+            const object = core.storage.findObject(property.subtype);
+            const isEntity = object?.type === object_type_1.ObjectType.entity;
+            return !isEntity;
+        }
+        return true;
+    })
+        .forEach((targetProperty) => {
+        const propertyKey = targetProperty.propertyKey;
+        const globalPath = `${currentPath}.${propertyKey}`;
+        let columnName;
+        const entityProperty = core
+            .storage
+            .getProperties(targetProperty.objectClass)
+            .find((p) => p.propertyKey === propertyKey);
+        if (entityProperty) {
+            columnName = entityProperty.columnName;
+        }
+        if (type === 'root' && !entityProperty) {
+            return;
+        }
+        if ((targetProperty.type === class_pipe_1.PropertyType.object && targetProperty.subtype)
+            || targetProperty.ifChecks?.length > 0) {
+            const hasIfChecks = targetProperty.ifChecks?.length > 0;
+            const objectTypes = hasIfChecks
+                ? targetProperty.ifChecks.map((ifCheck) => ifCheck.type)
+                : [targetProperty.subtype];
+            objectTypes.forEach((objectType) => {
+                (0, exports.loadProperties)({
+                    type: 'embedded',
+                    alias: propertyKey,
+                    properties,
+                    target: objectType,
+                    fullPath: currentPath,
+                    initializedObjects,
+                    rootEntity,
+                    rootFullPath: type === "embedded"
+                        ? rootFullPath
+                        : `${currentPath}.${targetProperty.propertyKey}`,
+                    parent: {
+                        alias,
+                        target,
+                        type,
+                        parent,
+                        entityAlias
+                    }
+                });
+            });
+        }
+        else {
+            properties[globalPath] = {
+                path: {
+                    target,
+                    alias,
+                    type,
+                    relation,
+                    parent,
+                    secure,
+                    entityAlias,
+                    rootOrRelationFullPath: rootFullPath
+                },
+                isUUID: targetProperty.type === class_pipe_1.PropertyType.string
+                    && targetProperty.validatorsConfigs?.some((cfg) => cfg.type === 'isUUID') || false,
+                columnName,
+                isArray: !!targetProperty.isArray,
+                isJson: !!targetProperty.isJSON,
+                fullPath: globalPath,
+                name: propertyKey,
+                type: targetProperty.type
+            };
+        }
+    });
+    if (paths) {
+        const idProperty = (0, get_id_property_1.getIdProperty)(target);
+        const pathKeys = Object.keys(paths);
+        for (const pathProperty of pathKeys) {
+            const path = paths[pathProperty];
+            const linkProperty = (path.type === 'indirect'
+                ? core.storage.getProperties(path.target()).find((p) => p.isRelation && p.getRelationType() === target)
+                : core.storage.getProperties(target).find((p) => p.isRelation && p.getRelationType() === path.target()));
+            if (!linkProperty) {
+                const line1 = `Unable to find linkProperty to ${path.alias}:${path.target()?.name} into query:${target.name}`;
+                const line2 = `Use @Relation(() => <target>) to define`;
+                throw new Error(`${line1}\n${line2}`);
+            }
+            const targetIdProperty = (0, get_id_property_1.getIdProperty)(path.target());
+            const condition = path.condition ?? (() => {
+                const linkName = path.linkProperty || linkProperty.columnName;
+                return path.type === "direct"
+                    ? `"${entityAlias}"."${linkName}" = "${path.alias}"."${targetIdProperty.columnName}"`
+                    : `"${entityAlias}"."${idProperty.columnName}" = "${path.alias}"."${linkName}"`;
+            })();
+            (0, exports.loadProperties)({
+                alias: pathProperty,
+                entityAlias: path.alias,
+                properties,
+                target: path.target(),
+                type: "relation",
+                paths: path.paths,
+                secure: path.secure,
+                rootEntity,
+                relation: {
+                    type: path.type,
+                    mapTo: `${alias}.${pathProperty}`,
+                    condition,
+                },
+                fullPath: currentPath,
+                parent: {
+                    alias,
+                    target,
+                    type,
+                    relation,
+                    parent,
+                    entityAlias
+                },
+                initializedObjects
+            });
+        }
+    }
+};
+exports.loadProperties = loadProperties;

package/query/functions/map-query-property-to-column-name.d.ts

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { IQueryObject } from "../interfaces/query-object";
+export declare const mapQueryPropertyToColumnName: (queryObject: ObjectNote<IQueryObject>, item: string) => string;

package/query/functions/map-query-property-to-column-name.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapQueryPropertyToColumnName = void 0;
+const mapQueryPropertyToColumnName = (queryObject, item) => {
+    const queryProperties = queryObject.properties;
+    const queryProperty = queryProperties[item];
+    switch (queryProperty.path.type) {
+        case "relation":
+        case "root":
+            return `${queryProperty.path.entityAlias}.${queryProperty.name}`;
+        case "embedded":
+            return queryProperty.path.rootOrRelationFullPath;
+        default:
+            throw new Error(`${item} not found on query`);
+    }
+};
+exports.mapQueryPropertyToColumnName = mapQueryPropertyToColumnName;

package/query/functions/replace-property-key-to-column-name.d.ts

@@ -0,0 +1 @@
+export declare const replacePropertyKeyToColumnName: (item: string, alias: string, propertyKey: string, columnName: string) => string;

package/query/functions/replace-property-key-to-column-name.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replacePropertyKeyToColumnName = void 0;
+const replacePropertyKeyToColumnName = (item, alias, propertyKey, columnName) => {
+    const replacedProperty = item.replace(propertyKey, columnName);
+    return !columnName.includes('_')
+        ? replacedProperty
+        : item;
+};
+exports.replacePropertyKeyToColumnName = replacePropertyKeyToColumnName;

package/query/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './query-action-options';
+export * from './query-object';
+export * from './query';

package/query/interfaces/index.js

@@ -0,0 +1,19 @@
+"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("./query-action-options"), exports);
+__exportStar(require("./query-object"), exports);
+__exportStar(require("./query"), exports);

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

@@ -0,0 +1,14 @@
+export type QueryActionOptions = {
+    /**
+     * 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;
+};

package/query/interfaces/query-action-options.js

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

package/query/interfaces/query-object.d.ts

@@ -0,0 +1,10 @@
+import { ObjectType } from "../../common";
+import { Dictionary } from "@rockster/common";
+import { QueryProperty } from "./query";
+import { IObject } from "../../core";
+import { RootPath } from "../../database";
+export interface IQueryObject extends IObject {
+    readonly type: ObjectType.query;
+    properties: Dictionary<QueryProperty>;
+    rootPath: RootPath<any>;
+}

package/query/interfaces/query-object.js

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

package/query/interfaces/query.d.ts

@@ -0,0 +1,54 @@
+import { PropertyType } from "@rockster/class-pipe";
+import { Instantiable } from "@rockster/common";
+import { GetConditionCallback } from "../../database/interfaces/path";
+export type OrderBy = {
+    direction: 'desc' | 'asc';
+    property: string;
+};
+export type Query<Entity> = {
+    select: string[];
+    filter?: string;
+    orderBy?: OrderBy[];
+    take?: number;
+    skip?: number;
+    total?: number;
+    filtered?: number;
+    data?: Entity[];
+    page?: boolean;
+};
+export type IQueryContent<Entity, ContextData = any> = {
+    userId?: string;
+    naviteSelect?: string[];
+    parameters?: Record<string, any>;
+    query: Query<Entity>;
+    target: Instantiable;
+    requestRef?: string;
+    context?: ContextData;
+    rootAlias?: string;
+};
+export type QueryRelationConfig = {
+    type: 'direct' | 'indirect';
+    mapTo?: string;
+    condition: string | GetConditionCallback<any>;
+};
+export type QueryPropertyType = 'root' | 'embedded' | 'relation';
+export type QueryPath = {
+    target: Instantiable;
+    alias: string;
+    type: QueryPropertyType;
+    relation?: QueryRelationConfig;
+    parent?: QueryPath;
+    secure?: boolean;
+    entityAlias: string;
+    rootOrRelationFullPath?: string;
+};
+export type QueryProperty = {
+    path: QueryPath;
+    isUUID?: boolean;
+    isArray?: boolean;
+    isJson?: boolean;
+    name: string;
+    type: PropertyType;
+    fullPath: string;
+    columnName?: string;
+};

package/query/interfaces/query.js

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

package/query/models/base-query-response.d.ts

@@ -0,0 +1,12 @@
+import { OrderBy, Query } from "../interfaces/query";
+export declare class BaseQueryResponse<T> implements Query<T> {
+    take?: number;
+    skip?: number;
+    total?: number;
+    filtered?: number;
+    data?: T[];
+    select: string[];
+    filter?: string;
+    orderBy?: OrderBy[];
+    page?: boolean;
+}

package/query/models/base-query-response.js

@@ -0,0 +1,41 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseQueryResponse = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+class BaseQueryResponse {
+}
+exports.BaseQueryResponse = BaseQueryResponse;
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsInt)(),
+    __metadata("design:type", Number)
+], BaseQueryResponse.prototype, "take", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsInt)(),
+    __metadata("design:type", Number)
+], BaseQueryResponse.prototype, "skip", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsInt)(),
+    __metadata("design:type", Number)
+], BaseQueryResponse.prototype, "total", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsInt)(),
+    __metadata("design:type", Number)
+], BaseQueryResponse.prototype, "filtered", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsArray)(),
+    __metadata("design:type", Array)
+], BaseQueryResponse.prototype, "data", void 0);

package/query/services/query-action-builder.d.ts

@@ -0,0 +1,14 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { IControllerObject, IControllerProperty } from "../../controllers/interfaces";
+import { ExecuteInterceptorHandle, IActionDocs, PendingAction, IRequestContext } from "../../core";
+import { ExecutorData } from "@rockster/class-injector/interfaces";
+import { Dictionary } from "@rockster/common";
+export declare class QueryActionBuilder {
+    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 onBefore(pending: PendingAction, context: IRequestContext, property: PropertyNote<IControllerProperty>): Promise<void>;
+    protected execute(pending: PendingAction, context: IRequestContext, data: ExecutorData, property: PropertyNote<IControllerProperty>): Promise<void>;
+}

package/query/services/query-action-builder.js

@@ -0,0 +1,145 @@
+"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.QueryActionBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const interfaces_1 = require("../../controllers/interfaces");
+const core_1 = require("../../core");
+const class_pipe_1 = require("@rockster/class-pipe");
+const constants_1 = require("../constants");
+const constants_2 = require("../../controllers/constants");
+const describe_query_filter_1 = require("../functions/describe-query-filter");
+const web_socket_1 = require("../../web-socket");
+let QueryActionBuilder = class QueryActionBuilder {
+    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.QUERY_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();
+        core.models.pushIfNotExists(Payload);
+        core.models.pushIfNotExists(Response);
+        return {
+            alias: object.alias,
+            name: name,
+            path: path,
+            description: property.description,
+            isSecure: isSecure,
+            payload: Payload.name,
+            response: Response.name
+        };
+    }
+    async onBefore(pending, context, property) {
+        if (property.data) {
+            const payload = context.request[pending.requestRef];
+            await this.beforeValidationInterceptors[pending.path]({
+                action: pending,
+                context: context,
+                property: property
+            });
+            const errors = await (0, class_pipe_1.validate)(property.data, payload);
+            if (errors) {
+                errors.target = pending.requestRef;
+                throw errors;
+            }
+            const sanitized = {
+                select: payload.select,
+                filter: payload.filter,
+                orderBy: payload.orderBy,
+                skip: payload.skip || 0,
+                take: payload.take || 10,
+                page: typeof payload.page === 'boolean'
+                    ? payload.page
+                    : true
+            };
+            const data = {};
+            Object
+                .getOwnPropertyNames(payload)
+                .filter((property) => {
+                return property.startsWith('$');
+            })
+                .forEach((property) => {
+                data[property] = payload[property];
+            });
+            const content = {
+                query: sanitized,
+                select: [],
+                target: property.data,
+                userId: context.session?.userId,
+                requestRef: pending.requestRef,
+                context: data
+            };
+            if (sanitized.filter) {
+                const data = (0, describe_query_filter_1.describeQueryFilter)(pending, property.data, sanitized, content.query.select);
+                sanitized.filter = data.translated;
+                content.parameters = data.parameters;
+            }
+            pending.annotations[constants_1.QUERY_CONTENT_KEY] = content;
+        }
+    }
+    async execute(pending, context, data, property) {
+        await this.beforeInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        });
+        const response = await data.handle({
+            [constants_1.QUERY_CONTENT_KEY]: pending.annotations[constants_1.QUERY_CONTENT_KEY],
+            [constants_2.REQUEST_CONTEXT_KEY]: context,
+            [web_socket_1.WS_CLIENT_KEY]: context.wsClient
+        });
+        context.response[pending.property] = response;
+        await this.afterInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        }, true);
+    }
+};
+exports.QueryActionBuilder = QueryActionBuilder;
+exports.QueryActionBuilder = QueryActionBuilder = __decorate([
+    (0, class_injector_1.Injectable)()
+], QueryActionBuilder);

package/security/auth.controller.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from "@rockster/logger";
+import { Instantiable } from "@rockster/common";
+export declare class AuthController {
+    protected logger: Logger;
+    active(target: Instantiable): Promise<void>;
+    protected validateSchema(): Promise<void>;
+    protected createController(target: Instantiable): Promise<void>;
+}

package/security/auth.controller.js

@@ -0,0 +1,68 @@
+"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.AuthController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const logger_1 = require("@rockster/logger");
+const env_1 = require("./env");
+const security_request_1 = require("./requests/security.request");
+const module_1 = require("../module");
+let AuthController = class AuthController {
+    constructor() {
+        this.logger = new logger_1.Logger('Security');
+    }
+    async active(target) {
+        if (!env_1.env.instance) {
+            await this.createController(target);
+        }
+        await this.validateSchema();
+    }
+    async validateSchema() {
+        if (!core.options.security.authorization) {
+            return;
+        }
+        const contexts = core
+            .options
+            .security
+            .authorization
+            .contexts;
+        for (const preSchemaContext of env_1.env.preSchema.contexts) {
+            const context = contexts
+                .find((context) => {
+                return context.protector() === preSchemaContext.protector();
+            });
+            if (!context) {
+                this.logger.throw(new Error(`AuthContext not found for {${preSchemaContext.protector().name}}`));
+            }
+            for (const key of preSchemaContext.keys) {
+                context
+                    .keys
+                    .pushIfNotExists(key, (source, target) => {
+                    return source.name === target.name;
+                });
+            }
+        }
+        env_1.env.schema = core
+            .options
+            .security
+            .authorization;
+        await module_1.ModuleController
+            .instance
+            .loadRequests([security_request_1.SecurityRequest]);
+        this.logger.log('Authorization successfully activated');
+    }
+    async createController(target) {
+        env_1.env.instance = await (0, class_injector_1.createInstance)(target);
+        core.isAuthEnabled = true;
+        this.logger.log('Authentication successfully activated');
+    }
+};
+exports.AuthController = AuthController;
+exports.AuthController = AuthController = __decorate([
+    (0, class_injector_1.Injectable)()
+], AuthController);

package/security/constants.js

@@ -0,0 +1,2 @@
+// export const adminKey = 'admin';
+// export const ownerKey = 'owner';

package/security/env.d.ts

@@ -0,0 +1,7 @@
+import { IAuthController } from "./interfaces/auth-controller";
+import { AuthorizationSchema } from "./interfaces/authorization-schema";
+export declare const env: {
+    instance: IAuthController;
+    schema: AuthorizationSchema;
+    preSchema: AuthorizationSchema;
+};

package/security/env.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+exports.env = {
+    instance: null,
+    schema: null,
+    preSchema: { contexts: [] }
+};

package/security/functions/add-protect.d.ts

@@ -0,0 +1,2 @@
+import { Instantiable } from "@rockster/common";
+export declare const addProtect: (target: Instantiable) => void;

package/security/functions/add-protect.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProtect = void 0;
+const env_1 = require("../env");
+const addProtect = (target) => {
+    env_1.env.preSchema.contexts.push({
+        protector: () => target
+    });
+};
+exports.addProtect = addProtect;

package/security/functions/add-protected.d.ts

@@ -0,0 +1,3 @@
+import { GetTypeCallback } from "../../common";
+import { IAuthorizationKey } from "../interfaces/authorization-schema";
+export declare const addProtected: (protector: GetTypeCallback, keys: IAuthorizationKey[]) => void;

package/security/functions/add-protected.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProtected = void 0;
+const env_1 = require("../env");
+const addProtected = (protector, keys) => {
+    let context = env_1.env
+        .preSchema
+        .contexts
+        .find((context) => {
+        return context.protector() === protector();
+    });
+    if (!context) {
+        context = {
+            protector: protector,
+            keys: keys || []
+        };
+        env_1.env.preSchema.contexts.push(context);
+    }
+    else {
+        context.keys.push(...keys);
+    }
+};
+exports.addProtected = addProtected;

package/security/functions/create-authorization.d.ts

@@ -0,0 +1,2 @@
+import { AuthorizationSchema } from "../interfaces/authorization-schema";
+export declare const createAuthorization: (schema: AuthorizationSchema) => AuthorizationSchema;