@rockster/core 0.0.1

package/command/interfaces/command-property.d.ts

@@ -0,0 +1,7 @@
+import { PropertyType } from "../../common";
+import { IProperty } from "../../core";
+export interface ICommandProperty extends IProperty {
+    type: PropertyType.postField;
+    onlyModify?: boolean;
+    readOnly?: boolean;
+}

package/command/interfaces/command-property.js

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

package/command/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+export * from './command-property';
+export * from './post-action-options';
+export * from './post-content';
+export * from './remove-aciton-options';
+export * from './remove-content';

package/command/interfaces/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("./command-property"), exports);
+__exportStar(require("./post-action-options"), exports);
+__exportStar(require("./post-content"), exports);
+__exportStar(require("./remove-aciton-options"), exports);
+__exportStar(require("./remove-content"), exports);

package/command/interfaces/post-action-options.d.ts

@@ -0,0 +1,23 @@
+import { GetTypeCallback } from "../../common";
+export type PostActionOptions = {
+    /**
+     * Entity
+     */
+    type: GetTypeCallback;
+    /**
+     * Custom name for action
+     */
+    name?: string;
+    /**
+     * Define the action is public and is not necessary to pass and userId. Default: false
+     */
+    public?: boolean;
+    /**
+     * Description for docs
+     */
+    description?: string;
+    /**
+     * Define sanitize body or no. Default: true
+     */
+    strict?: boolean;
+};

package/command/interfaces/post-action-options.js

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

package/command/interfaces/post-content.d.ts

@@ -0,0 +1,8 @@
+export type PostType = 'create' | 'modify';
+export interface IPostContent<Entity> {
+    target: Function;
+    idValue?: string;
+    idProperty?: string;
+    type: PostType;
+    data: Entity;
+}

package/command/interfaces/post-content.js

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

package/command/interfaces/remove-aciton-options.d.ts

@@ -0,0 +1,23 @@
+import { GetTypeCallback } from "../../common";
+export type RemoveActionOptions = {
+    /**
+     * Entity
+     */
+    type: GetTypeCallback;
+    /**
+     * 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;
+};

package/command/interfaces/remove-aciton-options.js

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

package/command/interfaces/remove-content.d.ts

@@ -0,0 +1,5 @@
+export interface IRemoveContent {
+    target: Function;
+    idValue: string;
+    idProperty: string;
+}

package/command/interfaces/remove-content.js

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

package/command/services/post-action-builder.d.ts

@@ -0,0 +1,19 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { ExecuteInterceptorHandle, IActionDocs, PendingAction, IRequestContext } from "../../core";
+import { ExecutorData } from "@rockster/class-injector/interfaces";
+import { Dictionary } from "@rockster/common";
+import { IControllerObject, IControllerProperty } from "../../controllers/interfaces";
+import { ICommandProperty } from "../interfaces";
+export declare class PostActionBuilder {
+    protected beforeInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    protected afterInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    protected beforeValidationInterceptors: Dictionary<ExecuteInterceptorHandle>;
+    protected readOnlyProperties: Dictionary<PropertyNote<ICommandProperty>>;
+    protected onlyModifyProperties: Dictionary<PropertyNote<ICommandProperty>>;
+    protected validProperties: Dictionary<boolean>;
+    create(object: ObjectNote<IControllerObject>): Promise<void>;
+    protected loadProperties(target: any, parent?: string, loaded?: any[]): 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/command/services/post-action-builder.js

@@ -0,0 +1,219 @@
+"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.PostActionBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const core_1 = require("../../core");
+const class_pipe_1 = require("@rockster/class-pipe");
+const interfaces_1 = require("../../controllers/interfaces");
+const constants_1 = require("../constants");
+const constants_2 = require("../../controllers/constants");
+const database_1 = require("../../database");
+const use_protector_1 = require("../../database/functions/use-protector");
+const constants_3 = require("../../web-socket/constants");
+const global_1 = require("../../global");
+let PostActionBuilder = class PostActionBuilder {
+    constructor() {
+        this.beforeInterceptors = {};
+        this.afterInterceptors = {};
+        this.beforeValidationInterceptors = {};
+        this.readOnlyProperties = {};
+        this.onlyModifyProperties = {};
+        this.validProperties = {};
+    }
+    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.POST_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);
+            this.loadProperties(property.data);
+            (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)
+            });
+        }
+    }
+    loadProperties(target, parent = '', loaded = []) {
+        if (!target) {
+            return;
+        }
+        const isLoaded = loaded
+            .find((item) => {
+            return item === target.name;
+        });
+        if (isLoaded) {
+            return;
+        }
+        loaded.pushIfNotExists(target.name);
+        const properties = (0, class_pipe_1.getValidationProperties)(target);
+        for (const property of properties) {
+            if (property.type === class_pipe_1.PropertyType.object) {
+                if (property.ifChecks?.length > 0) {
+                    property.ifChecks.forEach((ifCheck) => {
+                        this.loadProperties(ifCheck.type, `${parent}${target.name}.`, loaded);
+                    });
+                }
+                else {
+                    this.loadProperties(property.subtype, `${parent}${target.name}.`, loaded);
+                }
+            }
+            else {
+                const fullName = `${parent}${property.objectKey}.${property.propertyKey}`;
+                this.validProperties[fullName] = true;
+                const cProperty = core
+                    .storage
+                    .getProperties(target)
+                    .find((coreProperty) => {
+                    return coreProperty.propertyKey === property.propertyKey;
+                });
+                if (cProperty) {
+                    if (cProperty.readOnly) {
+                        this.readOnlyProperties[fullName] = cProperty;
+                    }
+                    if (cProperty.onlyModify) {
+                        this.onlyModifyProperties[fullName] = cProperty;
+                    }
+                }
+            }
+        }
+    }
+    createDocs(object, property, name, path, isSecure) {
+        const Payload = property.data;
+        core.models.pushIfNotExists(Payload);
+        return {
+            alias: object.alias,
+            name: name,
+            path: path,
+            description: property.description,
+            isSecure: isSecure,
+            payload: Payload.name,
+            response: Payload.name
+        };
+    }
+    async execute(pending, context, data, property) {
+        // Before Interceptor
+        await this.beforeInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        });
+        // End Before Interceptor
+        const response = await data.handle({
+            [constants_1.POST_CONTENT_KEY]: pending.annotations[constants_1.POST_CONTENT_KEY],
+            [constants_2.REQUEST_CONTEXT_KEY]: context,
+            [constants_3.WS_CLIENT_KEY]: context.wsClient
+        });
+        context.response[pending.property] = await (0, class_pipe_1.transform)({
+            target: property.data,
+            values: response
+        });
+        // After Interceptor
+        await this.afterInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        }, true);
+        // End After Interceptor
+    }
+    async onBefore(pending, context, property) {
+        // Before Validation Interceptor
+        await this
+            .beforeValidationInterceptors[pending.path]({
+            action: pending,
+            context: context,
+            property: property
+        });
+        // End Before Validation Interceptor
+        const groups = property.exposeGroups ?? [];
+        const payload = context.request[pending.requestRef];
+        const idProperty = (0, database_1.getIdProperty)(property.data);
+        const idValue = payload[idProperty.propertyKey];
+        const postType = !idValue ? 'create' : 'modify';
+        const sanitized = {};
+        const protector = (0, use_protector_1.useProtector)(property.data);
+        const errors = await (0, class_pipe_1.validate)(property.data, payload, sanitized, {
+            groups: postType === 'modify'
+                ? [global_1.actionGroups.modify, ...groups]
+                : [global_1.actionGroups.create, ...groups],
+            onlyData: postType === "modify"
+                ? true
+                : false,
+            ignore: async ({ parent, objectKey, propertyKey, value, isArray }) => {
+                const fullName = `${parent}${objectKey}.${propertyKey}`;
+                const isReadOnly = this.readOnlyProperties[fullName];
+                const isOnlyModify = this.onlyModifyProperties[fullName];
+                if (isReadOnly && postType === 'modify') {
+                    throw new class_pipe_1.PropertyError('Property cannot be modified after creation', `${parent}${propertyKey}`);
+                }
+                if (isOnlyModify && postType === 'create') {
+                    throw new class_pipe_1.PropertyError('Property cannot be created, only modified', `${parent}${propertyKey}`);
+                }
+                if (isArray && value?.length > 0) {
+                    return false;
+                }
+                return false;
+            }
+        });
+        if (errors) {
+            errors.target = pending.requestRef;
+            throw errors;
+        }
+        if (context.isAuthenticated && protector) {
+            if (postType === 'modify') {
+                await protector
+                    .canModify(context.session?.userId, payload, context.entityManager);
+            }
+            else {
+                await protector
+                    .canCreate(context.session?.userId, payload, context.entityManager);
+            }
+        }
+        const postContent = {
+            idProperty: idProperty.propertyKey,
+            data: property.content?.strict
+                ? sanitized
+                : payload,
+            type: postType,
+            target: property.data
+        };
+        if (postType === 'modify') {
+            postContent.idValue = idValue;
+            delete postContent.data[idProperty.propertyKey];
+        }
+        pending.annotations[constants_1.POST_CONTENT_KEY] = postContent;
+    }
+};
+exports.PostActionBuilder = PostActionBuilder;
+exports.PostActionBuilder = PostActionBuilder = __decorate([
+    (0, class_injector_1.Injectable)()
+], PostActionBuilder);

package/command/services/remove-action-builder.d.ts

@@ -0,0 +1,14 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { ExecuteInterceptorHandle, IActionDocs, PendingAction, IRequestContext } from "../../core";
+import { ExecutorData } from "@rockster/class-injector/interfaces";
+import { Dictionary } from "@rockster/common";
+import { IControllerObject, IControllerProperty } from "../../controllers/interfaces";
+export declare class RemoveActionBuilder {
+    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/command/services/remove-action-builder.js

@@ -0,0 +1,165 @@
+"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.RemoveActionBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const core_1 = require("../../core");
+const common_1 = require("@rockster/common");
+const interfaces_1 = require("../../controllers/interfaces");
+const constants_1 = require("../constants");
+const constants_2 = require("../../controllers/constants");
+const database_1 = require("../../database");
+const use_protector_1 = require("../../database/functions/use-protector");
+const use_repository_1 = require("../../database/functions/use-repository");
+const class_pipe_1 = require("@rockster/class-pipe");
+const executed_response_1 = require("../../common/models/executed-response");
+const constants_3 = require("../../web-socket/constants");
+let RemoveActionBuilder = class RemoveActionBuilder {
+    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.REMOVE_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.hasResponse
+            ? property.getResponseType()
+            : executed_response_1.ExecutedResponse;
+        core.models.pushIfNotExists(Payload);
+        core.models.pushIfNotExists(Response);
+        const idProperty = (0, database_1.getIdProperty)(Payload);
+        return {
+            alias: object.alias,
+            name: name,
+            path: path,
+            description: property.description,
+            isSecure: isSecure,
+            payload: `${Payload.name}.${idProperty.propertyKey}`,
+            response: Response.name
+        };
+    }
+    async execute(pending, context, data, property) {
+        // Before Interceptor
+        await this.beforeInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        });
+        // End Before Interceptor
+        const response = await data.handle({
+            [constants_1.REMOVE_CONTENT_KEY]: pending.annotations[constants_1.REMOVE_CONTENT_KEY],
+            [constants_2.REQUEST_CONTEXT_KEY]: context,
+            [constants_3.WS_CLIENT_KEY]: context.wsClient
+        });
+        if (property.getResponseType && response) {
+            const type = property.getResponseType();
+            context.response[pending.property] = 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] = {
+                status: 'executed'
+            };
+        }
+        // After Interceptor
+        await this.afterInterceptors[pending.path]({
+            action: pending,
+            context,
+            property
+        }, true);
+        // End After Interceptor
+    }
+    async onBefore(pending, context, property) {
+        // Before Validation Interceptor
+        await this
+            .beforeValidationInterceptors[pending.path]({
+            action: pending,
+            context: context,
+            property: property
+        });
+        // End Before Validation Interceptor
+        const idProperty = (0, database_1.getIdProperty)(property.data);
+        const idValue = context.request[pending.requestRef];
+        const protector = (0, use_protector_1.useProtector)(property.data);
+        if (protector) {
+            await protector
+                .canRemove(context.session?.userId, idValue, context.entityManager);
+        }
+        else {
+            const invalidError = new common_1.BadRequestError({
+                message: `invalid id value [${idValue}]`
+            });
+            try {
+                const repository = context.entityManager
+                    ? context.entityManager.getRepository(property.data)
+                    : (0, use_repository_1.useRepository)(property.data);
+                const stored = await repository
+                    .findOneBy({
+                    [idProperty.propertyKey]: idValue
+                });
+                if (!stored) {
+                    throw invalidError;
+                }
+            }
+            catch (error) {
+                throw invalidError;
+            }
+        }
+        const removeContent = {
+            target: property.data,
+            idProperty: idProperty.propertyKey,
+            idValue: idValue
+        };
+        pending.annotations[constants_1.REMOVE_CONTENT_KEY] = removeContent;
+    }
+};
+exports.RemoveActionBuilder = RemoveActionBuilder;
+exports.RemoveActionBuilder = RemoveActionBuilder = __decorate([
+    (0, class_injector_1.Injectable)()
+], RemoveActionBuilder);

package/command/utils/deep-merge-keep-undefined.d.ts

@@ -0,0 +1 @@
+export declare function deepMergeKeepUndefined<T>(target: T, source: Partial<T>): T;

package/command/utils/deep-merge-keep-undefined.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMergeKeepUndefined = deepMergeKeepUndefined;
+const lodash_1 = require("lodash");
+function deepMergeKeepUndefined(target, source) {
+    return (0, lodash_1.mergeWith)({}, target, source, (objValue, srcValue) => {
+        if (srcValue === undefined) {
+            return objValue;
+        }
+        if (Array.isArray(srcValue)) {
+            return srcValue;
+        }
+        if ((0, lodash_1.isObject)(objValue) && (0, lodash_1.isObject)(srcValue)) {
+            return deepMergeKeepUndefined(objValue, srcValue);
+        }
+        return srcValue;
+    });
+}

package/common/entities/base-entity.d.ts

@@ -0,0 +1,7 @@
+import { IBaseEntity } from '@rockster/common/transport';
+export declare abstract class BaseEntity implements IBaseEntity {
+    id?: string;
+    active?: boolean;
+    createdAt?: Date;
+    lastModifiedAt?: Date;
+}

package/common/entities/base-entity.js

@@ -0,0 +1,47 @@
+"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.BaseEntity = void 0;
+const id_generated_decorator_1 = require("../../database/decorators/id-generated.decorator");
+const column_decorator_1 = require("../../database/decorators/column.decorator");
+const class_pipe_1 = require("@rockster/class-pipe");
+class BaseEntity {
+}
+exports.BaseEntity = BaseEntity;
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    (0, id_generated_decorator_1.IdGenerated)('nanoid'),
+    __metadata("design:type", String)
+], BaseEntity.prototype, "id", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsBoolean)(),
+    (0, class_pipe_1.IsOptional)(),
+    (0, column_decorator_1.Column)({ default: true }),
+    __metadata("design:type", Boolean)
+], BaseEntity.prototype, "active", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsDate)(),
+    (0, column_decorator_1.Column)({
+        type: 'timestamp without time zone',
+        default: 'now()'
+    }),
+    __metadata("design:type", Date)
+], BaseEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, column_decorator_1.Column)({
+        type: 'timestamp without time zone',
+        default: 'now()'
+    }),
+    __metadata("design:type", Date)
+], BaseEntity.prototype, "lastModifiedAt", void 0);

package/common/index.d.ts

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

package/common/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("./interfaces"), exports);

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

@@ -0,0 +1,3 @@
+export * from './object-type';
+export * from './property-type';
+export * from './request-status';