@ruiapp/rapid-core 0.1.62 → 0.1.65

package/dist/dataAccess/dataAccessTypes.d.ts

@@ -6,7 +6,7 @@ export type RowFilterExistenceOperators = "exists" | "notExists";
 export type RowFilterOperators = RowFilterRelationalOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
 export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
 export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
-export type ColumnQueryOptions = string | ColumnNameWithTableName;
+export type ColumnSelectOptions = string | ColumnNameWithTableName;
 export type ColumnNameWithTableName = {
     name: string;
     tableName?: string;
@@ -15,16 +15,16 @@ export interface FindRowOptions {
     filters?: RowFilterOptions[];
     orderBy?: FindRowOrderByOptions[];
     pagination?: FindRowPaginationOptions;
-    fields?: ColumnQueryOptions[];
+    fields?: ColumnSelectOptions[];
     keepNonPropertyFields?: boolean;
 }
 export interface FindRowRelationalFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterRelationalOperators;
     value: any;
 }
 export interface FindRowSetFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterSetOperators;
     value: any[];
     itemType?: string;
@@ -34,11 +34,11 @@ export interface FindRowLogicalFilterOptions {
     filters: RowFilterOptions[];
 }
 export interface FindRowUnaryFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterUnaryOperators;
 }
 export interface FindRowExistenceFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterExistenceOperators;
     filters: RowFilterOptions[];
 }
@@ -48,7 +48,7 @@ export interface FindRowPaginationOptions {
     withoutTotal?: boolean;
 }
 export interface FindRowOrderByOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     desc?: boolean;
 }
 export interface CountRowOptions {

package/dist/dataAccess/entityManager.d.ts

@@ -1,5 +1,19 @@
-import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, UpdateEntityByIdOptions } from "../types";
+import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, FindEntitySelectRelationOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelProperty, UpdateEntityByIdOptions } from "../types";
 import { IRpdServer, RapidPlugin } from "../core/server";
+export type FindOneRelationEntitiesOptions = {
+    server: IRpdServer;
+    mainModel: RpdDataModel;
+    relationProperty: RpdDataModelProperty;
+    relationEntityIds: any[];
+    selectRelationOptions?: FindEntitySelectRelationOptions;
+};
+export type FindManyRelationEntitiesOptions = {
+    server: IRpdServer;
+    mainModel: RpdDataModel;
+    relationProperty: RpdDataModelProperty;
+    mainEntityIds: any[];
+    selectRelationOptions?: FindEntitySelectRelationOptions;
+};
 export default class EntityManager<TEntity = any> {
     #private;
     constructor(server: IRpdServer, dataAccessor: IRpdDataAccessor);

package/dist/helpers/entityHelpers.d.ts

@@ -1 +1,3 @@
-export declare function getEntityPartChanges(before: any, after: any): Record<string, any> | null;
+import { IRpdServer } from "../core/server";
+import { RpdDataModel } from "../types";
+export declare function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null;

package/dist/{dataAccess → helpers}/metaHelper.d.ts

@@ -1,5 +1,8 @@
 import { IRpdServer } from "../core/server";
 import { RpdDataModel, RpdDataModelProperty } from "../types";
+export declare function isRelationProperty(property: RpdDataModelProperty): boolean;
+export declare function isOneRelationProperty(property: RpdDataModelProperty): boolean;
+export declare function isManyRelationProperty(property: RpdDataModelProperty): boolean;
 export declare function getEntityProperties(server: IRpdServer, model: RpdDataModel): RpdDataModelProperty[];
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel): RpdDataModelProperty[];
 export declare function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty;

package/dist/index.js

@@ -277,9 +277,11 @@ class QueryBuilder {
             command += `${this.quoteObject(derivedModel.tableName)}.* FROM `;
         }
         else {
-            command += columns.map((column) => {
+            command += columns
+                .map((column) => {
                 return this.quoteColumn(column, ctx.emitTableAlias);
-            }).join(", ");
+            })
+                .join(", ");
             command += " FROM ";
         }
         command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
@@ -1091,7 +1093,12 @@ function validateValue(name, value) {
         return;
     for (let i = 0; i < value.length; i++) {
         const c = value.charAt(i);
-        if (c < String.fromCharCode(0x21) || c == String.fromCharCode(0x22) || c == String.fromCharCode(0x2c) || c == String.fromCharCode(0x3b) || c == String.fromCharCode(0x5c) || c == String.fromCharCode(0x7f)) {
+        if (c < String.fromCharCode(0x21) ||
+            c == String.fromCharCode(0x22) ||
+            c == String.fromCharCode(0x2c) ||
+            c == String.fromCharCode(0x3b) ||
+            c == String.fromCharCode(0x5c) ||
+            c == String.fromCharCode(0x7f)) {
             throw new Error("RFC2616 cookie '" + name + "' cannot contain character '" + c + "'");
         }
         if (c > String.fromCharCode(0x80)) {
@@ -1338,6 +1345,13 @@ var bootstrapApplicationConfig = {
                     type: "text",
                     required: false,
                 },
+                {
+                    name: "displayPropertyCode",
+                    code: "displayPropertyCode",
+                    columnName: "display_property_code",
+                    type: "text",
+                    required: false,
+                },
                 {
                     name: "properties",
                     code: "properties",
@@ -1798,8 +1812,10 @@ var bootstrapApplicationConfig$1 = /*#__PURE__*/Object.freeze({
 
 function isRelationProperty(property) {
     return property.type === "relation" || property.type === "relation[]";
-}
-
+}
+function isOneRelationProperty(property) {
+    return isRelationProperty(property) && property.relation === "one";
+}
 function getEntityPropertiesIncludingBase(server, model) {
     if (!model.base) {
         return model.properties;
@@ -1815,10 +1831,7 @@ function getEntityPropertiesIncludingBase(server, model) {
             return property;
         });
     }
-    return [
-        ...baseProperties,
-        ...model.properties,
-    ];
+    return [...baseProperties, ...model.properties];
 }
 function getEntityPropertyByCode(server, model, propertyCode) {
     return getEntityProperty(server, model, (e) => e.code === propertyCode);
@@ -1895,8 +1908,8 @@ function mapEntityToDbRow(server, model, entity) {
     if (!entity) {
         return result;
     }
-    const row = result.row = {};
-    const baseRow = result.baseRow = {};
+    const row = (result.row = {});
+    const baseRow = (result.baseRow = {});
     if (!model.properties || !model.properties.length) {
         return result;
     }
@@ -1944,25 +1957,80 @@ function mapPropertyNameToColumnName(model, propertyName) {
     return property.columnName || property.code;
 }
 
-function getEntityPartChanges(before, after) {
+function getEntityPartChanges(server, model, before, after) {
     if (!before) {
         throw new Error("Argument 'before' can not be null.");
     }
     if (!after) {
         throw new Error("Argument 'after' can not be null.");
     }
-    let changed = null;
+    let changed = false;
+    let changes = {};
     for (const key in after) {
-        if (after[key] != before[key]) {
-            if (changed) {
-                changed[key] = after[key];
+        const property = getEntityPropertyByCode(server, model, key);
+        if (isOneRelationProperty(property)) {
+            const afterValue = after[key];
+            const beforeValue = before[key] || before[property.targetIdColumnName];
+            if (afterValue) {
+                if (lodash.isNumber(afterValue)) {
+                    if (beforeValue) {
+                        if (lodash.isNumber(beforeValue)) {
+                            if (afterValue != beforeValue) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                        else {
+                            if (afterValue != beforeValue.id) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                    }
+                    else {
+                        changed = true;
+                        changes[key] = afterValue;
+                    }
+                }
+                else {
+                    if (beforeValue) {
+                        if (lodash.isNumber(beforeValue)) {
+                            if (afterValue.id != beforeValue) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                        else {
+                            if (afterValue.id != beforeValue.id) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                    }
+                    else {
+                        changed = true;
+                        changes[key] = afterValue;
+                    }
+                }
             }
             else {
-                changed = { [key]: after[key] };
+                if (beforeValue) {
+                    changed = true;
+                    changes[key] = null;
+                }
+            }
+        }
+        else {
+            if (after[key] != before[key]) {
+                changed = true;
+                changes[key] = after[key];
             }
         }
     }
-    return changed;
+    if (changed) {
+        return changes;
+    }
+    return null;
 }
 
 function getNowStringWithTimezone() {
@@ -2001,16 +2069,18 @@ async function findEntities(server, dataAccessor, options) {
             singularCode: model.base,
         });
     }
-    let propertiesToSlect;
+    let propertiesToSelect;
+    let relationOptions = options.relations || {};
+    let relationPropertyCodes = Object.keys(relationOptions) || [];
     if (!options.properties || !options.properties.length) {
-        propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property));
+        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property) || relationPropertyCodes.includes(property.code));
     }
     else {
-        propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code));
+        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code) || relationPropertyCodes.includes(property.code));
     }
     const columnsToSelect = [];
     const relationPropertiesToSelect = [];
-    lodash.forEach(propertiesToSlect, (property) => {
+    lodash.forEach(propertiesToSelect, (property) => {
         if (isRelationProperty(property)) {
             relationPropertiesToSelect.push(property);
             if (property.relation === "one" && !property.linkTableName) {
@@ -2058,6 +2128,31 @@ async function findEntities(server, dataAccessor, options) {
             }
         });
     }
+    if (options.extraColumnsToSelect) {
+        lodash.forEach(options.extraColumnsToSelect, (extraColumnToSelect) => {
+            const columnSelectOptionExists = lodash.find(columnsToSelect, (item) => {
+                if (typeof item === "string") {
+                    if (typeof extraColumnToSelect === "string") {
+                        return item === extraColumnToSelect;
+                    }
+                    else {
+                        return item == extraColumnToSelect.name;
+                    }
+                }
+                else {
+                    if (typeof extraColumnToSelect === "string") {
+                        return item.name === extraColumnToSelect;
+                    }
+                    else {
+                        return item.name == extraColumnToSelect.name;
+                    }
+                }
+            });
+            if (!columnSelectOptionExists) {
+                columnsToSelect.push(extraColumnToSelect);
+            }
+        });
+    }
     const rowFilters = await convertEntityFiltersToRowFilters(server, model, baseModel, options.filters);
     const findRowOptions = {
         filters: rowFilters,
@@ -2074,27 +2169,45 @@ async function findEntities(server, dataAccessor, options) {
         for (const relationProperty of relationPropertiesToSelect) {
             const isManyRelation = relationProperty.relation === "many";
             if (relationProperty.linkTableName) {
-                const targetModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
-                if (!targetModel) {
+                const relationModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
+                if (!relationModel) {
                     continue;
                 }
                 if (isManyRelation) {
-                    const relationLinks = await findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds);
+                    const relationLinks = await findManyRelationLinksViaLinkTable({
+                        server,
+                        mainModel: relationModel,
+                        relationProperty,
+                        mainEntityIds: entityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                     lodash.forEach(rows, (row) => {
                         row[relationProperty.code] = lodash.filter(relationLinks, (link) => {
                             return link[relationProperty.selfIdColumnName] == row["id"];
-                        }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, options.keepNonPropertyFields));
+                        }).map((link) => mapDbRowToEntity(server, relationModel, link.targetEntity, options.keepNonPropertyFields));
                     });
                 }
             }
             else {
                 let relatedEntities;
                 if (isManyRelation) {
-                    relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds);
+                    relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode({
+                        server,
+                        mainModel: model,
+                        relationProperty,
+                        mainEntityIds: entityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                 }
                 else {
                     const targetEntityIds = lodash.uniq(lodash.reject(lodash.map(rows, (entity) => entity[relationProperty.targetIdColumnName]), isNullOrUndefined));
-                    relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds);
+                    relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode({
+                        server,
+                        mainModel: model,
+                        relationProperty,
+                        relationEntityIds: targetEntityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                 }
                 const targetModel = server.getModel({
                     singularCode: relationProperty.targetSingularCode,
@@ -2354,68 +2467,99 @@ async function convertEntityFiltersToRowFilters(server, model, baseModel, filter
     }
     return replacedFilters;
 }
-async function findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds) {
+async function findManyRelationLinksViaLinkTable(options) {
+    const { server, relationProperty, mainModel: relationModel, mainEntityIds, selectRelationOptions } = options;
     const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
         schema: relationProperty.linkSchema,
         tableName: relationProperty.linkTableName,
     })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])`;
-    const params = [entityIds];
+    const params = [mainEntityIds];
     const links = await server.queryDatabaseObject(command, params);
     const targetEntityIds = links.map((link) => link[relationProperty.targetIdColumnName]);
+    const dataAccessor = server.getDataAccessor({
+        namespace: relationModel.namespace,
+        singularCode: relationModel.singularCode,
+    });
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: "id",
-                },
+                field: "id",
                 operator: "in",
                 value: targetEntityIds,
             },
         ],
+        keepNonPropertyFields: true,
     };
-    const dataAccessor = server.getDataAccessor({
-        namespace: targetModel.namespace,
-        singularCode: targetModel.singularCode,
-    });
-    const targetEntities = await dataAccessor.find(findEntityOptions);
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    const targetEntities = await findEntities(server, dataAccessor, findEntityOptions);
     lodash.forEach(links, (link) => {
         link.targetEntity = lodash.find(targetEntities, (e) => e["id"] == link[relationProperty.targetIdColumnName]);
     });
     return links;
 }
-function findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds) {
+async function findManyRelatedEntitiesViaIdPropertyCode(options) {
+    const { server, relationProperty, mainEntityIds, selectRelationOptions } = options;
+    const dataAccessor = server.getDataAccessor({
+        singularCode: relationProperty.targetSingularCode,
+    });
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: relationProperty.selfIdColumnName,
-                },
+                field: relationProperty.selfIdColumnName,
                 operator: "in",
-                value: entityIds,
+                value: mainEntityIds,
             },
         ],
+        extraColumnsToSelect: [relationProperty.selfIdColumnName],
+        keepNonPropertyFields: true,
     };
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    return await findEntities(server, dataAccessor, findEntityOptions);
+}
+async function findOneRelatedEntitiesViaIdPropertyCode(options) {
+    const { server, relationProperty, relationEntityIds, selectRelationOptions } = options;
     const dataAccessor = server.getDataAccessor({
         singularCode: relationProperty.targetSingularCode,
     });
-    return dataAccessor.find(findEntityOptions);
-}
-function findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds) {
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: "id",
-                },
+                field: "id",
                 operator: "in",
-                value: targetEntityIds,
+                value: relationEntityIds,
             },
         ],
+        keepNonPropertyFields: true,
     };
-    const dataAccessor = server.getDataAccessor({
-        singularCode: relationProperty.targetSingularCode,
-    });
-    return dataAccessor.find(findEntityOptions);
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    return await findEntities(server, dataAccessor, findEntityOptions);
 }
 async function createEntity(server, dataAccessor, options, plugin) {
     const model = dataAccessor.getModel();
@@ -2494,7 +2638,7 @@ async function createEntity(server, dataAccessor, options, plugin) {
                 targetRow[property.targetIdColumnName] = targetEntityId;
             }
         }
-        else {
+        else if (lodash.isNumber(fieldValue)) {
             // fieldValue is id;
             const targetEntityId = fieldValue;
             const targetEntity = await findById(server, targetDataAccessor, {
@@ -2507,6 +2651,10 @@ async function createEntity(server, dataAccessor, options, plugin) {
             newEntityOneRelationProps[property.code] = targetEntity;
             targetRow[property.targetIdColumnName] = targetEntityId;
         }
+        else {
+            newEntityOneRelationProps[property.code] = null;
+            targetRow[property.targetIdColumnName] = null;
+        }
     }
     let newBaseRow;
     if (model.base) {
@@ -2615,14 +2763,15 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         throw new Error("Id is required when updating an entity.");
     }
     const entity = await findById(server, dataAccessor, {
-        id,
         routeContext,
+        id,
+        keepNonPropertyFields: true,
     });
     if (!entity) {
         throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
     let { entityToSave } = options;
-    let changes = getEntityPartChanges(entity, entityToSave);
+    let changes = getEntityPartChanges(server, model, entity, entityToSave);
     if (!changes && !options.operation) {
         return entity;
     }
@@ -2652,7 +2801,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         sender: plugin,
         routeContext: options.routeContext,
     });
-    changes = getEntityPartChanges(entity, entityToSave);
+    changes = getEntityPartChanges(server, model, entity, entityToSave);
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
     lodash.keys(changes).forEach((propertyCode) => {
@@ -2700,7 +2849,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
                 targetRow[property.targetIdColumnName] = targetEntityId;
             }
         }
-        else {
+        else if (lodash.isNumber(fieldValue)) {
             // fieldValue is id;
             const targetEntityId = fieldValue;
             const targetEntity = await findById(server, targetDataAccessor, {
@@ -2713,6 +2862,10 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
             updatedEntityOneRelationProps[property.code] = targetEntity;
             targetRow[property.targetIdColumnName] = targetEntityId;
         }
+        else {
+            updatedEntityOneRelationProps[property.code] = null;
+            targetRow[property.targetIdColumnName] = null;
+        }
     }
     let updatedRow = row;
     if (Object.keys(row).length) {
@@ -2946,11 +3099,11 @@ class EntityManager {
                 const command = `INSERT INTO ${queryBuilder.quoteTable({
                     schema: relationProperty.linkSchema,
                     tableName: relationProperty.linkTableName,
-                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
-    SELECT $1, $2 WHERE NOT EXISTS (
-      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
-        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
-        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
+                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
+    SELECT $1, $2 WHERE NOT EXISTS (
+      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
+        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
       )`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -2990,7 +3143,7 @@ class EntityManager {
         const { queryBuilder } = server;
         if (relationProperty.linkTableName) {
             for (const relation of relations) {
-                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
     WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2;`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -3701,7 +3854,10 @@ async function syncDatabaseSchema(server, applicationConfig) {
                 }
                 else if (property.relation === "many") {
                     if (property.linkTableName) {
-                        const tableInDb = lodash.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName });
+                        const tableInDb = lodash.find(tablesInDb, {
+                            table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema,
+                            table_name: property.linkTableName,
+                        });
                         if (!tableInDb) {
                             columnDDL = generateLinkTableDDL(queryBuilder, {
                                 linkSchema: property.linkSchema,
@@ -6101,9 +6257,9 @@ class EntityAccessControlPlugin {
         if (!userId) {
             return;
         }
-        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
-      inner join oc_role_sys_action_links ra on a.id = ra.action_id
-      inner join oc_role_user_links ru on ru.role_id = ra.role_id
+        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
+      inner join oc_role_sys_action_links ra on a.id = ra.action_id
+      inner join oc_role_user_links ru on ru.role_id = ra.role_id
       where ru.user_id = $1;`, [userId]);
         routeContext.state.allowedActions = actions.map((item) => item.code);
     }

package/dist/plugins/setting/SettingPlugin.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Setting plugin
+ */
+import { RpdApplicationConfig } from "../../types";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+import SettingService from "./SettingService";
+declare class SettingPlugin implements RapidPlugin {
+    #private;
+    get settingService(): SettingService;
+    get code(): string;
+    get description(): string;
+    get extendingAbilities(): RpdServerPluginExtendingAbilities[];
+    get configurableTargets(): RpdServerPluginConfigurableTargetOptions[];
+    get configurations(): RpdConfigurationItemOptions[];
+    registerActionHandlers(server: IRpdServer): Promise<any>;
+    configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
+}
+export default SettingPlugin;

package/dist/plugins/setting/SettingPluginTypes.d.ts

@@ -0,0 +1,31 @@
+export type SettingGroupSetting = {
+    code: string;
+    name: string;
+    description?: string;
+    permissionAssignments?: PermissionAssignment[];
+};
+export type SettingItemSetting = {
+    group: SettingGroupSetting;
+    orderNum: number;
+    type: string;
+    code: string;
+    name: string;
+    description?: string;
+    config?: any;
+};
+export type SystemSettingItem = {
+    groupCode: string;
+    itemCode: string;
+    value: any;
+};
+export type UserSettingItem = {
+    userId: number;
+    groupCode: string;
+    itemCode: string;
+    value: any;
+};
+export type PermissionAssignment = {
+    assigneeType: string;
+    assigneeId: number;
+    actions: string[];
+};

package/dist/plugins/setting/SettingService.d.ts

@@ -0,0 +1,10 @@
+import { IRpdServer } from "../../core/server";
+export interface GetSystemSettingValuesInput {
+    groupCode: string;
+}
+export default class SequenceService {
+    #private;
+    constructor(server: IRpdServer);
+    getSystemSettingValues(input: GetSystemSettingValuesInput): Promise<void>;
+    setSystemSettingValue(groupCode: string, itemCode: string, value: any): Promise<void>;
+}