@ruiapp/rapid-core 0.1.71 → 0.1.73

package/dist/dataAccess/dataAccessTypes.d.ts

@@ -10,6 +10,7 @@ export type ColumnSelectOptions = string | ColumnNameWithTableName;
 export type ColumnNameWithTableName = {
     name: string;
     tableName?: string;
+    schema?: string;
 };
 export interface FindRowOptions {
     filters?: RowFilterOptions[];
@@ -48,8 +49,18 @@ export interface FindRowPaginationOptions {
     withoutTotal?: boolean;
 }
 export interface FindRowOrderByOptions {
+    /**
+     * 排序字段
+     */
     field: ColumnSelectOptions;
+    /**
+     * 是否倒序
+     */
     desc?: boolean;
+    /**
+     * 关系字段
+     */
+    relationField?: ColumnNameWithTableName;
 }
 export interface CountRowOptions {
     filters?: RowFilterOptions[];

package/dist/dataAccess/propertyMapper.d.ts

@@ -1,3 +1,4 @@
 import { RpdDataModel } from "../types";
-export declare function mapPropertyNameToColumnName(model: RpdDataModel, propertyName: string): string;
-export declare function mapPropertyNamesToColumnNames(model: RpdDataModel, propertyNames: string[]): string[];
+import { IRpdServer } from "../core/server";
+export declare function mapPropertyNameToColumnName(server: IRpdServer, model: RpdDataModel, propertyName: string): string;
+export declare function mapPropertyNamesToColumnNames(server: IRpdServer, model: RpdDataModel, propertyNames: string[]): string[];

package/dist/helpers/metaHelper.d.ts

@@ -7,3 +7,4 @@ export declare function getEntityProperties(server: IRpdServer, model: RpdDataMo
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel): RpdDataModelProperty[];
 export declare function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty;
 export declare function getEntityProperty(server: IRpdServer, model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty;
+export declare function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty;

package/dist/index.js

@@ -212,33 +212,50 @@ class QueryBuilder {
     quoteObject(name) {
         return `${objLeftQuoteChar}${name}${objRightQuoteChar}`;
     }
-    quoteColumn(column, emitTableAlias) {
+    quoteColumn(model, column, emitTableAlias) {
         if (typeof column === "string") {
-            return `${objLeftQuoteChar}${column}${objRightQuoteChar}`;
-        }
-        else if (emitTableAlias && column.tableName) {
-            return `${objLeftQuoteChar}${column.tableName}${objRightQuoteChar}.${objLeftQuoteChar}${column.name}${objRightQuoteChar}`;
+            if (emitTableAlias) {
+                return `${objLeftQuoteChar}${model.tableName}${objRightQuoteChar}.${objLeftQuoteChar}${column}${objRightQuoteChar}`;
+            }
+            else {
+                return `${objLeftQuoteChar}${column}${objRightQuoteChar}`;
+            }
         }
         else {
-            return `${objLeftQuoteChar}${column.name}${objRightQuoteChar}`;
+            if (emitTableAlias && column.tableName) {
+                return `${objLeftQuoteChar}${column.tableName}${objRightQuoteChar}.${objLeftQuoteChar}${column.name}${objRightQuoteChar}`;
+            }
+            else {
+                return `${objLeftQuoteChar}${column.name}${objRightQuoteChar}`;
+            }
         }
     }
     select(model, options) {
         const ctx = {
+            model,
             builder: this,
             params: [],
-            emitTableAlias: false,
+            emitTableAlias: true,
         };
         let { fields: columns, filters, orderBy, pagination } = options;
         let command = "SELECT ";
         if (!columns || !columns.length) {
-            command += "* FROM ";
+            command += `${this.quoteObject(model.tableName)}.* FROM `;
         }
         else {
-            command += columns.map((column) => this.quoteColumn(column, ctx.emitTableAlias)).join(", ");
+            command += columns.map((column) => this.quoteColumn(ctx.model, column, ctx.emitTableAlias)).join(", ");
             command += " FROM ";
         }
         command += this.quoteTable(model);
+        if (options.orderBy) {
+            options.orderBy
+                .filter((orderByItem) => orderByItem.relationField)
+                .forEach((orderByItem) => {
+                const { relationField } = orderByItem;
+                const orderField = orderByItem.field;
+                command += ` LEFT JOIN ${this.quoteTable({ schema: orderField.schema, tableName: orderField.tableName })} ON ${this.quoteObject(orderField.tableName)}.id = ${this.quoteObject(relationField.tableName)}.${this.quoteObject(relationField.name)}`;
+            });
+        }
         if (filters && filters.length) {
             command += " WHERE ";
             command += buildFiltersQuery(ctx, filters);
@@ -247,7 +264,7 @@ class QueryBuilder {
             command += " ORDER BY ";
             command += orderBy
                 .map((item) => {
-                const quotedName = this.quoteColumn(item.field, ctx.emitTableAlias);
+                const quotedName = this.quoteColumn(ctx.model, item.field, ctx.emitTableAlias);
                 return item.desc ? quotedName + " DESC" : quotedName;
             })
                 .join(", ");
@@ -267,6 +284,7 @@ class QueryBuilder {
     }
     selectDerived(derivedModel, baseModel, options) {
         const ctx = {
+            model: derivedModel,
             builder: this,
             params: [],
             emitTableAlias: true,
@@ -279,12 +297,21 @@ class QueryBuilder {
         else {
             command += columns
                 .map((column) => {
-                return this.quoteColumn(column, ctx.emitTableAlias);
+                return this.quoteColumn(derivedModel, column, ctx.emitTableAlias);
             })
                 .join(", ");
             command += " FROM ";
         }
         command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
+        if (options.orderBy) {
+            options.orderBy
+                .filter((orderByItem) => orderByItem.relationField)
+                .forEach((orderByItem) => {
+                const { relationField } = orderByItem;
+                const orderField = orderByItem.field;
+                command += ` LEFT JOIN ${this.quoteTable({ schema: orderField.schema, tableName: orderField.tableName })} ON ${this.quoteObject(orderField.tableName)}.id = ${this.quoteObject(relationField.tableName)}.${this.quoteObject(relationField.name)}`;
+            });
+        }
         if (filters && filters.length) {
             command += " WHERE ";
             command += buildFiltersQuery(ctx, filters);
@@ -293,7 +320,7 @@ class QueryBuilder {
             command += " ORDER BY ";
             command += orderBy
                 .map((item) => {
-                const quotedName = this.quoteColumn(item.field, ctx.emitTableAlias);
+                const quotedName = this.quoteColumn(derivedModel, item.field, ctx.emitTableAlias);
                 return item.desc ? quotedName + " DESC" : quotedName;
             })
                 .join(", ");
@@ -313,6 +340,7 @@ class QueryBuilder {
     }
     count(model, options) {
         const ctx = {
+            model,
             builder: this,
             params: [],
             emitTableAlias: false,
@@ -331,6 +359,7 @@ class QueryBuilder {
     }
     countDerived(derivedModel, baseModel, options) {
         const ctx = {
+            model: derivedModel,
             builder: this,
             params: [],
             emitTableAlias: true,
@@ -350,6 +379,7 @@ class QueryBuilder {
     insert(model, options) {
         const params = [];
         const ctx = {
+            model,
             builder: this,
             params,
             emitTableAlias: false,
@@ -386,6 +416,7 @@ class QueryBuilder {
     update(model, options) {
         const params = [];
         const ctx = {
+            model,
             builder: this,
             params,
             emitTableAlias: false,
@@ -425,6 +456,7 @@ class QueryBuilder {
     delete(model, options) {
         const params = [];
         const ctx = {
+            model,
             builder: this,
             params,
             emitTableAlias: false,
@@ -499,7 +531,7 @@ function buildLogicalFilterQuery(level, ctx, filter) {
     return command;
 }
 function buildUnaryFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     if (filter.operator === "null") {
         command += " IS NULL";
     }
@@ -509,7 +541,7 @@ function buildUnaryFilterQuery(ctx, filter) {
     return command;
 }
 function buildInFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     if (filter.operator === "in") {
         command += " = ";
     }
@@ -521,49 +553,49 @@ function buildInFilterQuery(ctx, filter) {
     return command;
 }
 function buildContainsFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
     ctx.params.push(`%${filter.value}%`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildNotContainsFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
     ctx.params.push(`%${filter.value}%`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildStartsWithFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
     ctx.params.push(`${filter.value}%`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildNotStartsWithFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
     ctx.params.push(`${filter.value}%`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildEndsWithFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
     ctx.params.push(`%${filter.value}`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildNotEndsWithFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
     ctx.params.push(`%${filter.value}`);
     command += "$" + ctx.params.length;
     return command;
 }
 function buildRelationalFilterQuery(ctx, filter) {
-    let command = ctx.builder.quoteColumn(filter.field, ctx.emitTableAlias);
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += relationalOperatorsMap.get(filter.operator);
     ctx.params.push(filter.value);
     command += "$" + ctx.params.length;
@@ -1816,6 +1848,9 @@ function isRelationProperty(property) {
 function isOneRelationProperty(property) {
     return isRelationProperty(property) && property.relation === "one";
 }
+function isManyRelationProperty(property) {
+    return isRelationProperty(property) && property.relation === "many";
+}
 function getEntityPropertiesIncludingBase(server, model) {
     if (!model.base) {
         return model.properties;
@@ -1852,6 +1887,16 @@ function getEntityProperty(server, model, predicate) {
         }
     }
     return property;
+}
+function getEntityPropertyByFieldName(server, model, fieldName) {
+    let property = getEntityPropertyByCode(server, model, fieldName);
+    if (!property) {
+        property = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === fieldName);
+    }
+    if (!property) {
+        property = getEntityProperty(server, model, (item) => item.columnName === fieldName);
+    }
+    return property;
 }
 
 // TODO Generate mapper and cache it.
@@ -1943,15 +1988,15 @@ function mapEntityToDbRow(server, model, entity) {
     return result;
 }
 
-function mapPropertyNameToColumnName(model, propertyName) {
+function mapPropertyNameToColumnName(server, model, propertyName) {
     if (!model.properties) {
         return propertyName;
     }
-    const property = model.properties.find((item) => item.code === propertyName);
+    const property = getEntityPropertyByCode(server, model, propertyName);
     if (!property) {
         return propertyName;
     }
-    if (isRelationProperty(property) && property.relation === "one") {
+    if (isOneRelationProperty(property)) {
         return property.targetIdColumnName;
     }
     return property.columnName || property.code;
@@ -2042,23 +2087,60 @@ function convertEntityOrderByToRowOrderBy(server, model, baseModel, orderByList)
         return null;
     }
     return orderByList.map((orderBy) => {
-        let property = getEntityPropertyByCode(server, model, orderBy.field);
-        if (!property) {
-            property = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === orderBy.field);
+        const fields = orderBy.field.split(".");
+        let orderField;
+        let relationField;
+        if (fields.length === 1) {
+            orderField = fields[0];
         }
-        if (!property) {
-            property = getEntityProperty(server, model, (item) => item.columnName === orderBy.field);
+        else {
+            orderField = fields[1];
+            relationField = fields[0];
         }
-        if (!property) {
-            throw new Error(`Unkown orderBy field '${orderBy.field}'`);
+        if (relationField) {
+            const relationProperty = getEntityPropertyByCode(server, model, relationField);
+            if (!isRelationProperty(relationProperty)) {
+                throw new Error("orderBy[].relation must be a one-relation property.");
+            }
+            if (isManyRelationProperty(relationProperty)) {
+                throw new Error("orderBy[].relation must be a one-relation property.");
+            }
+            const relationModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
+            let relationBaseModel = null;
+            if (relationModel.base) {
+                relationBaseModel = server.getModel({ singularCode: relationModel.base });
+            }
+            let property = getEntityPropertyByFieldName(server, relationModel, orderField);
+            if (!property) {
+                throw new Error(`Unkown orderBy field '${orderField}' of relation '${relationField}'`);
+            }
+            return {
+                field: {
+                    name: mapPropertyNameToColumnName(server, relationModel, orderField),
+                    tableName: property.isBaseProperty ? relationBaseModel.tableName : relationModel.tableName,
+                    schema: property.isBaseProperty ? relationBaseModel.schema : relationModel.schema,
+                },
+                relationField: {
+                    name: mapPropertyNameToColumnName(server, model, relationField),
+                    tableName: relationProperty.isBaseProperty ? baseModel.tableName : model.tableName,
+                    schema: relationProperty.isBaseProperty ? baseModel.schema : model.schema,
+                },
+                desc: !!orderBy.desc,
+            };
+        }
+        else {
+            let property = getEntityPropertyByFieldName(server, model, orderField);
+            if (!property) {
+                throw new Error(`Unkown orderBy field '${orderField}'`);
+            }
+            return {
+                field: {
+                    name: mapPropertyNameToColumnName(server, model, orderField),
+                    tableName: property.isBaseProperty ? baseModel.tableName : model.tableName,
+                },
+                desc: !!orderBy.desc,
+            };
         }
-        return {
-            field: {
-                name: mapPropertyNameToColumnName(model, orderBy.field),
-                tableName: property.isBaseProperty ? baseModel.tableName : model.tableName,
-            },
-            desc: !!orderBy.desc,
-        };
     });
 }
 async function findEntities(server, dataAccessor, options) {
@@ -3099,11 +3181,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);
@@ -3143,7 +3225,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);
@@ -5558,15 +5640,19 @@ const code$7 = "downloadFile";
 async function handler$7(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
-    const dataAccessor = ctx.server.getDataAccessor({
-        singularCode: "ecm_storage_object",
-    });
-    const storageObject = await dataAccessor.findById(input.fileId);
-    if (!storageObject) {
-        ctx.output = { error: new Error("Storage object not found.") };
-        return;
+    //TODO: only public files can download by this handler
+    let fileKey = input.fileKey;
+    if (!fileKey && input.fileId) {
+        const dataAccessor = ctx.server.getDataAccessor({
+            singularCode: "ecm_storage_object",
+        });
+        const storageObject = await dataAccessor.findById(input.fileId);
+        if (!storageObject) {
+            ctx.output = { error: new Error("Storage object not found.") };
+            return;
+        }
+        fileKey = storageObject.key;
     }
-    const fileKey = storageObject.key;
     const filePathName = path__default["default"].join(server.config.localFileStoragePath, fileKey);
     const attachmentFileName = input.fileName || path__default["default"].basename(fileKey);
     response.body = await readFile(filePathName);

package/dist/queryBuilder/queryBuilder.d.ts

@@ -1,6 +1,7 @@
 import { RpdDataModel, CreateEntityOptions, QuoteTableOptions, DatabaseQuery } from "../types";
 import { CountRowOptions, DeleteRowOptions, FindRowOptions, RowFilterOptions, UpdateRowOptions, ColumnSelectOptions } from "../dataAccess/dataAccessTypes";
 export interface BuildQueryContext {
+    model: RpdDataModel;
     builder: QueryBuilder;
     params: any[];
     emitTableAlias: boolean;
@@ -13,7 +14,7 @@ export default class QueryBuilder {
     constructor(options: InitQueryBuilderOptions);
     quoteTable(options: QuoteTableOptions): string;
     quoteObject(name: string): string;
-    quoteColumn(column: ColumnSelectOptions, emitTableAlias: boolean): string;
+    quoteColumn(model: RpdDataModel, column: ColumnSelectOptions, emitTableAlias: boolean): string;
     select(model: RpdDataModel, options: FindRowOptions): DatabaseQuery;
     selectDerived(derivedModel: RpdDataModel, baseModel: RpdDataModel, options: FindRowOptions): DatabaseQuery;
     count(model: RpdDataModel, options: CountRowOptions): DatabaseQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",