@rockster/core 0.0.1

package/database/services/protect-builder.js

@@ -0,0 +1,523 @@
+"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.ProtectBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const common_1 = require("@rockster/common");
+const __1 = require("..");
+const use_repository_1 = require("../functions/use-repository");
+const find_auth_context_1 = require("../../security/functions/find-auth-context");
+let ProtectBuilder = class ProtectBuilder {
+    async build(object) {
+        if (object.protected) {
+            core.isAuthRequired = true;
+            await this.buildProtectedConfig(object);
+        }
+        if (object.isProtect) {
+            await this.buildProtectorConfig(object);
+        }
+    }
+    buildProtectorConfig(object) {
+        const protectorData = this
+            .getProtectorData(object.objectClass);
+        object.protector = {
+            isAuthorized: ({ keys, userId, context, contextId, entityManager }) => {
+                return this.checkIsAuthorized({
+                    context,
+                    contextId,
+                    data: protectorData,
+                    keys,
+                    userId,
+                    entityManager
+                });
+            },
+            getUserPermissions: this.getGetUserPermissions(protectorData),
+            setUserPermissions: this.getSetUserPermissions(protectorData)
+        };
+    }
+    getRepository(target, entityManager) {
+        return entityManager
+            ? entityManager.getRepository(target)
+            : (0, use_repository_1.useRepository)(target);
+    }
+    createQueryBuilder({ authKeys, data, protectorData, userId, displayContext, entityManager, protectedData }) {
+        let contextSQL = '';
+        let keySQL = '';
+        let contextName = protectedData
+            ? protectedData.object.objectKey
+            : displayContext;
+        const repository = this
+            .getRepository(protectorData.object.objectClass, entityManager);
+        const userIdValue = Number.isInteger(userId)
+            ? userId
+            : `'${userId}'`;
+        if (protectorData.context) {
+            const contextId = protectedData
+                ? data[protectedData.context.propertyKey]
+                : data[protectorData.context.propertyKey];
+            if (!contextId) {
+                throw new common_1.ForbiddenError({
+                    message: `Context value not found for [${contextName}]`
+                });
+            }
+            const contextIdValue = Number.isInteger(contextId)
+                ? contextId
+                : `'${contextId}'`;
+            contextSQL = ` AND "${protectorData.object.alias}"."${protectorData.context.propertyKey}" = ${contextIdValue}`;
+        }
+        if (protectorData.key && authKeys?.length > 0) {
+            const keysFilter = this
+                .buildFilterKeys(protectorData.object.alias, protectorData.key.propertyKey, authKeys);
+            keySQL = ` AND (${keysFilter})`;
+        }
+        const queryBuilder = repository
+            .createQueryBuilder(protectorData.object.alias)
+            .where(`
+            "${protectorData.object.alias}"."${protectorData.target.propertyKey}" = ${userIdValue}
+            ${contextSQL}
+            ${keySQL}
+         `);
+        return queryBuilder;
+    }
+    buildFilterKeys(protectorAlias, protectorKey, keys) {
+        let keysFilter = '';
+        for (const key of keys) {
+            if (keysFilter) {
+                keysFilter += ' OR ';
+            }
+            ;
+            keysFilter += `"${protectorAlias}"."${protectorKey}" = '${key}'`;
+        }
+        return keysFilter;
+    }
+    getQueryContextAndKeyCondition(protectorData, protectedData, protectorAlias, alias, contextParams, rootPath) {
+        let context = '';
+        let key = '';
+        if (protectorData.context) {
+            const protectorContext = protectorData.context.propertyKey;
+            const protectedContext = protectedData.context.propertyKey;
+            context = ` AND "${alias}"."${protectedContext}" = "${protectorAlias}"."${protectorContext}"`;
+            if (!protectedData.isContext) {
+                if (rootPath && rootPath !== protectorData.context.getRelationType()) {
+                    const contextId = contextParams[`$${protectorContext}`];
+                    if (!contextId) {
+                        throw new common_1.ValidationError({
+                            properties: [{
+                                    message: `Context value is required to this query`,
+                                    property: `$${protectorContext}`,
+                                    value: contextId
+                                }]
+                        });
+                    }
+                    const contextIdValue = Number.isInteger(contextId)
+                        ? contextId
+                        : `'${contextId}'`;
+                    context = `${context} AND "${alias}"."${protectedContext}" = ${contextIdValue}`;
+                }
+            }
+        }
+        if (protectorData.key
+            && protectedData.options?.keys?.read) {
+            const authContext = (0, find_auth_context_1.findAuthContext)(protectorData.object.objectClass);
+            const keysFilter = this
+                .buildFilterKeys(protectorAlias, protectorData.key.propertyKey, [
+                protectedData.options.keys.read.name,
+                authContext.adminKey.name,
+                authContext.ownerKey.name
+            ]);
+            key = ` AND (${keysFilter})`;
+        }
+        return {
+            context,
+            key
+        };
+    }
+    buildProtectedConfig(object) {
+        const protectorData = this
+            .getProtectorData(object.protected.type());
+        const protectedData = this
+            .getProtectedData(protectorData, object);
+        const overrideData = {
+            canCreateProtector: null,
+            canCreateProtected: null,
+            canRemoveProtector: null,
+            canRemoveProtected: null,
+            canModifyProtector: null,
+            canModifyProtected: null,
+            canReadProtector: null,
+            canReadProtected: null
+        };
+        if (protectedData.options?.keys?.create?.protector) {
+            overrideData.canCreateProtector = this.getProtectorData(protectedData.options.keys.create.protector());
+            overrideData.canCreateProtected = this.getProtectedData(overrideData.canCreateProtector, object);
+        }
+        if (protectedData.options?.keys?.modify?.protector) {
+            overrideData.canModifyProtector = this.getProtectorData(protectedData.options.keys.modify.protector());
+            overrideData.canModifyProtected = this.getProtectedData(overrideData.canModifyProtector, object);
+        }
+        if (protectedData.options?.keys?.read?.protector) {
+            overrideData.canReadProtector = this.getProtectorData(protectedData.options.keys.read.protector());
+            overrideData.canReadProtected = this.getProtectedData(overrideData.canReadProtector, object);
+        }
+        if (protectedData.options?.keys?.remove?.protector) {
+            overrideData.canRemoveProtector = this.getProtectorData(protectedData.options.keys.remove.protector());
+            overrideData.canRemoveProtected = this.getProtectedData(overrideData.canRemoveProtector, object);
+        }
+        object.protector = {
+            target: protectorData.object.objectClass,
+            relationCondition: ({ userId, contextParams, alias, rootPath }) => {
+                const protectorAlias = `${protectorData.object.alias}_${protectedData.object.alias}`;
+                const protectorTarget = protectorData.target.propertyKey;
+                const userIdValue = Number.isInteger(userId)
+                    ? userId
+                    : `'${userId}'`;
+                const { context, key } = this
+                    .getQueryContextAndKeyCondition(protectorData, protectedData, protectorAlias, alias, contextParams, rootPath);
+                let condition = `
+               AND EXISTS (
+                  SELECT * FROM "${protectorData.object.tableName}" "${protectorAlias}"
+                     WHERE "${protectorAlias}"."${protectorTarget}" = ${userIdValue}
+                     ${context}${key}
+               )
+            `;
+                return condition;
+            },
+            rootCondition: ({ userId, contextParams, queryBuilder, rootAlias }) => {
+                const protectorAlias = `${protectorData.object.alias}_${protectedData.object.alias}`;
+                const protectorTarget = protectorData.target.propertyKey;
+                const userIdValue = Number.isInteger(userId)
+                    ? userId
+                    : `'${userId}'`;
+                const { context, key } = this
+                    .getQueryContextAndKeyCondition(protectorData, protectedData, protectorAlias, rootAlias, contextParams);
+                queryBuilder.innerJoin(protectorData.object.objectClass, protectorAlias, `"${protectorAlias}"."${protectorTarget}" = ${userIdValue}${context}${key}`);
+                return queryBuilder;
+            },
+            canCreate: async (userId, data, entityManager) => {
+                const canCreateProtectorData = overrideData.canCreateProtector || protectorData;
+                const canCreateProtectedData = overrideData.canCreateProtected || protectedData;
+                const key = canCreateProtectedData.options?.keys?.create?.name;
+                if (!key) {
+                    return;
+                }
+                const forbiddenError = new common_1.ForbiddenError({
+                    message: `Current user [${userId}] cannot create [${canCreateProtectedData.object.objectClass.name}]`,
+                    requirements: [key]
+                });
+                const authContext = (0, find_auth_context_1.findAuthContext)(canCreateProtectorData.object.objectClass);
+                const exists = await this
+                    .createQueryBuilder({
+                    protectorData: canCreateProtectorData,
+                    userId,
+                    data,
+                    authKeys: key
+                        ? [
+                            key,
+                            authContext.adminKey.name,
+                            authContext.ownerKey.name
+                        ]
+                        : [],
+                    protectedData: canCreateProtectedData,
+                    entityManager
+                })
+                    .getOne();
+                if (!exists) {
+                    throw forbiddenError;
+                }
+            },
+            canRemove: async (userId, entityId, entityManager) => {
+                const canRemoveProtectorData = overrideData.canRemoveProtector || protectorData;
+                const canRemoveProtectedData = overrideData.canRemoveProtected || protectedData;
+                const key = canRemoveProtectedData.options?.keys?.remove?.name;
+                if (!key) {
+                    return;
+                }
+                const forbiddenError = new common_1.ForbiddenError({
+                    message: `Current user [${userId}] cannot remove [${canRemoveProtectedData.object.objectClass.name}]`,
+                    requirements: [key]
+                });
+                let storedValue;
+                const repository = this
+                    .getRepository(canRemoveProtectedData.object.objectClass, entityManager);
+                const invalidError = new common_1.BadRequestError({
+                    message: `invalid id value [${entityId}]`
+                });
+                try {
+                    storedValue = await repository
+                        .findOneBy({
+                        [canRemoveProtectedData.object.idProperty]: entityId
+                    });
+                    if (!storedValue) {
+                        throw invalidError;
+                    }
+                }
+                catch (error) {
+                    throw invalidError;
+                }
+                const authContext = (0, find_auth_context_1.findAuthContext)(canRemoveProtectorData.object.objectClass);
+                const exists = await this
+                    .createQueryBuilder({
+                    protectorData: canRemoveProtectorData,
+                    userId,
+                    data: storedValue,
+                    authKeys: key
+                        ? [
+                            key,
+                            authContext.adminKey.name,
+                            authContext.ownerKey.name
+                        ]
+                        : [],
+                    protectedData: canRemoveProtectedData,
+                    entityManager
+                })
+                    .getOne();
+                if (!exists) {
+                    throw forbiddenError;
+                }
+            },
+            canModify: async (userId, data, entityManager) => {
+                const canModifyProtectorData = overrideData.canModifyProtector || protectorData;
+                const canModifyProtectedData = overrideData.canModifyProtected || protectedData;
+                const key = canModifyProtectedData.options?.keys?.modify?.name;
+                if (!key) {
+                    return;
+                }
+                const forbiddenError = new common_1.ForbiddenError({
+                    message: `Current user [${userId}] cannot modify [${canModifyProtectedData.object.objectClass.name}]`,
+                    requirements: [key]
+                });
+                const repository = this
+                    .getRepository(canModifyProtectedData.object.objectClass, entityManager);
+                const storedId = data[canModifyProtectedData.object.idProperty];
+                if (!storedId) {
+                    throw new common_1.ForbiddenError({
+                        message: `Context value not found for [${canModifyProtectedData.object.objectClass.name}]`
+                    });
+                }
+                if (canModifyProtectorData.context) {
+                    try {
+                        const storedValue = await repository
+                            .findOneBy({
+                            [canModifyProtectedData.object.idProperty]: storedId
+                        });
+                        data[canModifyProtectedData.context.propertyKey] = storedValue[canModifyProtectedData.context.propertyKey];
+                    }
+                    catch (error) {
+                        throw new common_1.BadRequestError({
+                            message: `invalid id value [${storedId}]`
+                        });
+                    }
+                }
+                const authContext = (0, find_auth_context_1.findAuthContext)(canModifyProtectorData.object.objectClass);
+                const exists = await this
+                    .createQueryBuilder({
+                    protectorData: canModifyProtectorData,
+                    userId,
+                    data,
+                    authKeys: key
+                        ? [
+                            key,
+                            authContext.adminKey.name,
+                            authContext.ownerKey.name
+                        ]
+                        : [],
+                    protectedData: canModifyProtectedData,
+                    entityManager
+                })
+                    .getOne();
+                if (!exists) {
+                    throw forbiddenError;
+                }
+            }
+        };
+    }
+    getSetUserPermissions(data) {
+        return async ({ contextId, userId, entityManager, context, targetUserId, accessKeys }) => {
+            const authContext = (0, find_auth_context_1.findAuthContext)(context);
+            await this.checkIsAuthorized({
+                data,
+                context,
+                contextId,
+                keys: [
+                    authContext.adminKey.name,
+                    authContext.ownerKey.name
+                ],
+                userId,
+                entityManager
+            });
+            if (targetUserId === userId
+                && !accessKeys.find((accessKey) => accessKey === authContext.ownerKey.name)
+                && !accessKeys.find((accessKey) => accessKey === authContext.adminKey.name)) {
+                throw new common_1.ForbiddenError({
+                    message: `User cannot revoke their own permissions`
+                });
+            }
+            const repository = entityManager
+                .getRepository(data.object.objectClass);
+            const { keyProperty, contextProperty, targetProperty, where } = this.getAuthContextFilter(targetUserId, data, contextId);
+            const newAccessKeys = accessKeys.map((accessKey, i) => {
+                const isKey = authContext
+                    .keys
+                    ?.find((key) => {
+                    return key.name === accessKey;
+                });
+                if (!isKey
+                    && accessKey !== authContext.adminKey.name
+                    && accessKey !== authContext.ownerKey.name) {
+                    throw new common_1.BadRequestError({
+                        message: `accessKeys[${i}] is not valid`
+                    });
+                }
+                const newAccessKey = {
+                    [targetProperty.propertyKey]: targetUserId,
+                    [keyProperty.propertyKey]: accessKey
+                };
+                if (contextProperty) {
+                    newAccessKey[contextProperty.propertyKey] = contextId;
+                }
+                return newAccessKey;
+            });
+            await repository.delete(where);
+            await repository.save(newAccessKeys);
+        };
+    }
+    getGetUserPermissions(data) {
+        return async ({ contextId, userId, targetUserId, entityManager, context }) => {
+            const authContext = (0, find_auth_context_1.findAuthContext)(context);
+            if (userId !== targetUserId) {
+                await this.checkIsAuthorized({
+                    data,
+                    context,
+                    contextId,
+                    keys: [
+                        authContext.adminKey.name,
+                        authContext.ownerKey.name
+                    ],
+                    userId,
+                    entityManager
+                });
+            }
+            const repository = entityManager
+                .getRepository(data.object.objectClass);
+            const { keyProperty, where } = this.getAuthContextFilter(targetUserId, data, contextId);
+            const accessKeys = await repository.findBy(where);
+            return accessKeys.map((accessKey) => {
+                return accessKey[keyProperty.propertyKey];
+            });
+        };
+    }
+    getAuthContextFilter(targetUserId, data, contextId) {
+        const properties = core
+            .storage
+            .getProperties(data.object.objectClass);
+        const contextProperty = properties
+            .find((property) => {
+            return property.isProtectContext;
+        });
+        const keyProperty = properties
+            .find((property) => {
+            return property.isProtectKey;
+        });
+        const targetProperty = properties
+            .find((property) => {
+            return property.isProtectTarget;
+        });
+        const where = {
+            [targetProperty.propertyKey]: targetUserId
+        };
+        if (contextProperty) {
+            where[contextProperty.propertyKey] = contextId;
+        }
+        return {
+            where,
+            keyProperty,
+            contextProperty,
+            targetProperty
+        };
+    }
+    async checkIsAuthorized({ data, userId, entityManager, keys, context, contextId }) {
+        const forbiddenError = new common_1.ForbiddenError({
+            message: `[${userId}] cannot execute action on [${context || data.object.objectKey}]`,
+            requirements: [keys.join(',')]
+        });
+        const exists = await this
+            .createQueryBuilder({
+            protectorData: data,
+            userId,
+            data: data.context
+                ? { [data.context.propertyKey]: contextId }
+                : {},
+            authKeys: keys,
+            displayContext: context,
+            entityManager
+        })
+            .getOne();
+        if (!exists) {
+            throw forbiddenError;
+        }
+    }
+    getProtectedData(protector, object) {
+        let context;
+        let options = object.protected;
+        let isContext = false;
+        if (protector.context) {
+            isContext = object.objectClass === protector.context.getRelationType();
+            context = isContext
+                ? (0, __1.getIdProperty)(object.objectClass)
+                : core
+                    .storage
+                    .getProperties(object.objectClass)
+                    .find((property) => {
+                    return property.isRelation
+                        && property.getRelationType() === protector.context.getRelationType();
+                });
+            if (!context) {
+                throw new Error(`[${protector.object.objectClass.name}] Context property not found on protected entity [${object.objectClass.name}]`);
+            }
+        }
+        return {
+            object,
+            options,
+            context: context,
+            isContext
+        };
+    }
+    getProtectorData(protector) {
+        const object = core
+            .storage
+            .findObject(protector);
+        const target = core
+            .storage
+            .getProperties(protector)
+            .find((property) => {
+            return property.isProtectTarget;
+        });
+        const context = core
+            .storage
+            .getProperties(protector)
+            .find((property) => {
+            return property.isProtectContext;
+        });
+        const key = core
+            .storage
+            .getProperties(protector)
+            .find((property) => {
+            return property.isProtectKey;
+        });
+        return {
+            object,
+            target: target,
+            context: context,
+            key: key
+        };
+    }
+};
+exports.ProtectBuilder = ProtectBuilder;
+exports.ProtectBuilder = ProtectBuilder = __decorate([
+    (0, class_injector_1.Injectable)()
+], ProtectBuilder);

package/database/services/repository.service.d.ts

@@ -0,0 +1,14 @@
+import { Repository } from "../interfaces";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import { FindManyOptions, FindOneOptions, FindOptionsWhere } from 'typeorm';
+export declare abstract class RepositoryService<T> {
+    protected abstract repository: Repository<T>;
+    getOne(options: FindOneOptions<T>): Promise<T>;
+    getMany(options?: FindManyOptions<T>): Promise<T[]>;
+    getOneBy(where: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<T>;
+    saveMany(values: QueryDeepPartialEntity<T>[]): Promise<import("typeorm").InsertResult>;
+    save(value: T): Promise<T>;
+    updateBy(criteria: FindOptionsWhere<T>, update: QueryDeepPartialEntity<T>): Promise<import("typeorm").UpdateResult>;
+    removeBy(where: FindOptionsWhere<T>): Promise<import("typeorm").DeleteResult>;
+    upsert(data: QueryDeepPartialEntity<T>, columns: (keyof T)[]): Promise<T>;
+}

package/database/services/repository.service.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryService = void 0;
+const generate_id_1 = __importDefault(require("../functions/generate-id"));
+const get_id_property_1 = require("../functions/get-id-property");
+class RepositoryService {
+    async getOne(options) {
+        return this
+            .repository
+            .findOne(options);
+    }
+    async getMany(options) {
+        return this
+            .repository
+            .find(options);
+    }
+    async getOneBy(where) {
+        return this
+            .repository
+            .findOneBy(where);
+    }
+    async saveMany(values) {
+        return this
+            .repository
+            .insert(values.map((value) => {
+            (0, generate_id_1.default)(this.repository.target, value);
+            return value;
+        }));
+    }
+    async save(value) {
+        const idProperty = (0, get_id_property_1.getIdProperty)(this.repository.target);
+        if (!value[idProperty.propertyKey]) {
+            (0, generate_id_1.default)(this.repository.target, value);
+        }
+        return this
+            .repository
+            .save(value);
+    }
+    async updateBy(criteria, update) {
+        return this
+            .repository
+            .update(criteria, update);
+    }
+    async removeBy(where) {
+        return this
+            .repository
+            .delete(where);
+    }
+    async upsert(data, columns) {
+        await this
+            .repository
+            .upsert(data, columns);
+        const alias = this
+            .repository
+            .target
+            .constructor
+            .name;
+        let conditions = '';
+        for (const column of columns) {
+            const value = typeof data[column] === 'number'
+                ? data[column]
+                : `'${data[column]}'`;
+            conditions += `${!isNullOrEmpty(conditions) ? ' AND ' : ''}"${alias}"."${column}" = ${value}`;
+        }
+        return this
+            .repository
+            .createQueryBuilder(alias)
+            .where(conditions)
+            .getOne();
+    }
+}
+exports.RepositoryService = RepositoryService;

package/forms/entities/form.d.ts

@@ -0,0 +1,8 @@
+import { IForm } from "../interfaces/form";
+export declare class Form implements IForm {
+    id?: string;
+    name?: string;
+    items?: any[];
+    config?: any;
+    contextId?: string;
+}

package/forms/entities/form.js

@@ -0,0 +1,61 @@
+"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.Form = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+const database_1 = require("../../database");
+let Form = class Form {
+};
+exports.Form = Form;
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    (0, class_pipe_1.IsOptional)(),
+    (0, database_1.IdGenerated)('nanoid'),
+    __metadata("design:type", String)
+], Form.prototype, "id", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    (0, database_1.Column)(),
+    (0, class_pipe_1.IsRequired)(),
+    __metadata("design:type", String)
+], Form.prototype, "name", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)({ ignoreType: true }),
+    (0, class_pipe_1.IsOptional)(),
+    (0, class_pipe_1.IsArray)(),
+    (0, database_1.Column)({
+        type: 'jsonb',
+        default: '[]'
+    }),
+    __metadata("design:type", Array)
+], Form.prototype, "items", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)({ ignoreType: true }),
+    (0, class_pipe_1.IsOptional)(),
+    (0, class_pipe_1.IsObject)(),
+    (0, database_1.Column)({
+        type: 'jsonb',
+        default: '{}'
+    }),
+    __metadata("design:type", Object)
+], Form.prototype, "config", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsOptional)(),
+    (0, class_pipe_1.IsString)(),
+    (0, database_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], Form.prototype, "contextId", void 0);
+exports.Form = Form = __decorate([
+    (0, database_1.Entity)()
+], Form);

package/forms/entities/property.d.ts

@@ -0,0 +1,7 @@
+import { IProperty } from "../interfaces/property";
+export declare class Property implements IProperty {
+    id?: string;
+    name?: string;
+    config?: any;
+    contextId?: string;
+}