@ruiapp/rapid-core 0.1.73 → 0.1.74

package/dist/bootstrapApplicationConfig.d.ts

@@ -2,6 +2,78 @@ declare const _default: {
     code: string;
     name: string;
     models: ({
+        maintainedBy: string;
+        namespace: string;
+        name: string;
+        singularCode: string;
+        pluralCode: string;
+        schema: string;
+        tableName: string;
+        properties: ({
+            name: string;
+            code: string;
+            columnName: string;
+            type: "integer";
+            required: true;
+            autoIncrement: true;
+            relation?: undefined;
+            targetSingularCode?: undefined;
+            selfIdColumnName?: undefined;
+        } | {
+            name: string;
+            code: string;
+            columnName: string;
+            type: "text";
+            required: true;
+            autoIncrement?: undefined;
+            relation?: undefined;
+            targetSingularCode?: undefined;
+            selfIdColumnName?: undefined;
+        } | {
+            name: string;
+            code: string;
+            columnName: string;
+            type: "text";
+            required: false;
+            autoIncrement?: undefined;
+            relation?: undefined;
+            targetSingularCode?: undefined;
+            selfIdColumnName?: undefined;
+        } | {
+            name: string;
+            code: string;
+            type: "relation[]";
+            relation: "many";
+            targetSingularCode: string;
+            selfIdColumnName: string;
+            columnName?: undefined;
+            required?: undefined;
+            autoIncrement?: undefined;
+        } | {
+            name: string;
+            code: string;
+            columnName: string;
+            type: "json";
+            required: false;
+            autoIncrement?: undefined;
+            relation?: undefined;
+            targetSingularCode?: undefined;
+            selfIdColumnName?: undefined;
+        })[];
+        indexes: ({
+            name: string;
+            properties: {
+                code: string;
+            }[];
+            unique: true;
+        } | {
+            name: string;
+            properties: {
+                code: string;
+            }[];
+            unique: false;
+        })[];
+    } | {
         maintainedBy: string;
         namespace: string;
         name: string;
@@ -87,6 +159,13 @@ declare const _default: {
             targetIdColumnName?: undefined;
             defaultValue?: undefined;
         })[];
+        indexes: {
+            name: string;
+            properties: {
+                code: string;
+            }[];
+            unique: true;
+        }[];
     } | {
         maintainedBy: string;
         namespace: string;
@@ -162,6 +241,7 @@ declare const _default: {
             autoIncrement?: undefined;
             defaultValue?: undefined;
         })[];
+        indexes?: undefined;
     } | {
         maintainedBy: string;
         namespace: string;
@@ -237,6 +317,7 @@ declare const _default: {
             targetIdColumnName?: undefined;
             defaultValue?: undefined;
         })[];
+        indexes?: undefined;
     } | {
         maintainedBy: string;
         namespace: string;
@@ -274,6 +355,7 @@ declare const _default: {
             required: true;
             autoIncrement?: undefined;
         })[];
+        indexes?: undefined;
     })[];
     routes: {
         namespace: string;

package/dist/dataAccess/entityManager.d.ts

@@ -1,5 +1,6 @@
-import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, FindEntitySelectRelationOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelProperty, UpdateEntityByIdOptions } from "../types";
+import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, FindEntitySelectRelationOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelIndex, RpdDataModelProperty, UpdateEntityByIdOptions } from "../types";
 import { IRpdServer, RapidPlugin } from "../core/server";
+import { RouteContext } from "../core/routeContext";
 export type FindOneRelationEntitiesOptions = {
     server: IRpdServer;
     mainModel: RpdDataModel;
@@ -14,6 +15,12 @@ export type FindManyRelationEntitiesOptions = {
     mainEntityIds: any[];
     selectRelationOptions?: FindEntitySelectRelationOptions;
 };
+export type CheckEntityDuplicatedOptions = {
+    routeContext?: RouteContext;
+    entityId?: number;
+    entityToSave: any;
+    indexConfig: RpdDataModelIndex;
+};
 export default class EntityManager<TEntity = any> {
     #private;
     constructor(server: IRpdServer, dataAccessor: IRpdDataAccessor);

package/dist/index.js

@@ -236,6 +236,7 @@ class QueryBuilder {
             builder: this,
             params: [],
             emitTableAlias: true,
+            paramToLiteral: false,
         };
         let { fields: columns, filters, orderBy, pagination } = options;
         let command = "SELECT ";
@@ -288,6 +289,7 @@ class QueryBuilder {
             builder: this,
             params: [],
             emitTableAlias: true,
+            paramToLiteral: false,
         };
         let { fields: columns, filters, orderBy, pagination } = options;
         let command = "SELECT ";
@@ -344,6 +346,7 @@ class QueryBuilder {
             builder: this,
             params: [],
             emitTableAlias: false,
+            paramToLiteral: false,
         };
         let { filters } = options;
         let command = 'SELECT COUNT(*)::int as "count" FROM ';
@@ -363,6 +366,7 @@ class QueryBuilder {
             builder: this,
             params: [],
             emitTableAlias: true,
+            paramToLiteral: false,
         };
         let { filters } = options;
         let command = 'SELECT COUNT(*)::int as "count" FROM ';
@@ -383,6 +387,7 @@ class QueryBuilder {
             builder: this,
             params,
             emitTableAlias: false,
+            paramToLiteral: false,
         };
         const { entity } = options;
         let command = "INSERT INTO ";
@@ -420,6 +425,7 @@ class QueryBuilder {
             builder: this,
             params,
             emitTableAlias: false,
+            paramToLiteral: false,
         };
         let { entity, filters } = options;
         let command = "UPDATE ";
@@ -460,6 +466,7 @@ class QueryBuilder {
             builder: this,
             params,
             emitTableAlias: false,
+            paramToLiteral: false,
         };
         let { filters } = options;
         let command = "DELETE FROM ";
@@ -473,6 +480,17 @@ class QueryBuilder {
             params: ctx.params,
         };
     }
+    buildFiltersExpression(model, filters) {
+        const params = [];
+        const ctx = {
+            model,
+            builder: this,
+            params,
+            emitTableAlias: false,
+            paramToLiteral: true,
+        };
+        return buildFiltersQuery(ctx, filters);
+    }
 }
 function buildFiltersQuery(ctx, filters) {
     return buildFilterQuery(0, ctx, {
@@ -548,58 +566,99 @@ function buildInFilterQuery(ctx, filter) {
     else {
         command += " <> ";
     }
-    ctx.params.push(filter.value);
-    command += `ANY($${ctx.params.length}::${filter.itemType || "int"}[])`;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(filter.value);
+        command += `ANY($${ctx.params.length}::${filter.itemType || "int"}[])`;
+    }
     return command;
 }
 function buildContainsFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
-    ctx.params.push(`%${filter.value}%`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`%${filter.value}%`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildNotContainsFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
-    ctx.params.push(`%${filter.value}%`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`%${filter.value}%`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildStartsWithFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
-    ctx.params.push(`${filter.value}%`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`${filter.value}%`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildNotStartsWithFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
-    ctx.params.push(`${filter.value}%`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`${filter.value}%`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildEndsWithFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
-    ctx.params.push(`%${filter.value}`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`%${filter.value}`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildNotEndsWithFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " NOT LIKE ";
-    ctx.params.push(`%${filter.value}`);
-    command += "$" + ctx.params.length;
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(`%${filter.value}`);
+        command += "$" + ctx.params.length;
+    }
     return command;
 }
 function buildRelationalFilterQuery(ctx, filter) {
     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;
+    if (ctx.paramToLiteral) {
+        command += formatValueToSqlLiteral(filter.value);
+    }
+    else {
+        ctx.params.push(filter.value);
+        command += "$" + ctx.params.length;
+    }
     return command;
+}
+function formatValueToSqlLiteral(value) {
+    if (lodash.isNull(value) || lodash.isUndefined(value)) {
+        return "null";
+    }
+    if (lodash.isString(value)) {
+        return `'${value.replaceAll("'", "''")}'`;
+    }
+    if (lodash.isBoolean(value)) {
+        return value ? "true" : "false";
+    }
+    if (lodash.isNumber(value)) {
+        return value.toString();
+    }
+    return `'${value.toString().replaceAll("'", "''")}'`;
 }
 
 class PluginManager {
@@ -1392,6 +1451,42 @@ var bootstrapApplicationConfig = {
                     targetSingularCode: "property",
                     selfIdColumnName: "model_id",
                 },
+                {
+                    name: "indexes",
+                    code: "indexes",
+                    columnName: "indexes",
+                    type: "json",
+                    required: false,
+                },
+            ],
+            indexes: [
+                {
+                    name: "meta_models_singular_code_uindex",
+                    properties: [
+                        {
+                            code: "singularCode",
+                        },
+                    ],
+                    unique: true,
+                },
+                {
+                    name: "meta_models_table_name_uindex",
+                    properties: [
+                        {
+                            code: "tableName",
+                        },
+                    ],
+                    unique: true,
+                },
+                {
+                    name: "meta_models_name_index",
+                    properties: [
+                        {
+                            code: "name",
+                        },
+                    ],
+                    unique: false,
+                },
             ],
         },
         {
@@ -1549,6 +1644,20 @@ var bootstrapApplicationConfig = {
                     required: false,
                 },
             ],
+            indexes: [
+                {
+                    name: "meta_properties_model_id_code_uindex",
+                    properties: [
+                        {
+                            code: "model",
+                        },
+                        {
+                            code: "code",
+                        },
+                    ],
+                    unique: true,
+                },
+            ],
         },
         {
             maintainedBy: "metaManager",
@@ -2672,6 +2781,24 @@ async function createEntity(server, dataAccessor, options, plugin) {
         sender: plugin,
         routeContext,
     });
+    // check unique constraints
+    if (!options.postponeUniquenessCheck) {
+        if (model.indexes && model.indexes.length) {
+            for (const indexConfig of model.indexes) {
+                if (!indexConfig.unique) {
+                    continue;
+                }
+                const duplicate = await willEntityDuplicate(server, dataAccessor, {
+                    routeContext: options.routeContext,
+                    entityToSave: entity,
+                    indexConfig,
+                });
+                if (duplicate) {
+                    throw new Error(getEntityDuplicatedErrorMessage(server, model, indexConfig));
+                }
+            }
+        }
+    }
     const oneRelationPropertiesToCreate = [];
     const manyRelationPropertiesToCreate = [];
     lodash.keys(entity).forEach((propertyCode) => {
@@ -2884,6 +3011,25 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         routeContext: options.routeContext,
     });
     changes = getEntityPartChanges(server, model, entity, entityToSave);
+    // check unique constraints
+    if (!options.postponeUniquenessCheck) {
+        if (model.indexes && model.indexes.length) {
+            for (const indexConfig of model.indexes) {
+                if (!indexConfig.unique) {
+                    continue;
+                }
+                const duplicate = await willEntityDuplicate(server, dataAccessor, {
+                    routeContext: options.routeContext,
+                    entityId: id,
+                    entityToSave: changes,
+                    indexConfig,
+                });
+                if (duplicate) {
+                    throw new Error(getEntityDuplicatedErrorMessage(server, model, indexConfig));
+                }
+            }
+        }
+    }
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
     lodash.keys(changes).forEach((propertyCode) => {
@@ -3065,6 +3211,55 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     });
     return updatedEntity;
 }
+async function willEntityDuplicate(server, dataAccessor, options) {
+    const { entityId, entityToSave, routeContext, indexConfig } = options;
+    let filters = [];
+    if (indexConfig.conditions) {
+        filters = lodash.cloneDeep(indexConfig.conditions);
+    }
+    for (const propConfig of indexConfig.properties) {
+        let propCode;
+        if (lodash.isString(propConfig)) {
+            propCode = propConfig;
+        }
+        else {
+            propCode = propConfig.code;
+        }
+        if (!entityToSave.hasOwnProperty(propCode)) {
+            // skip duplicate checking when  any index prop missing in entityToSave.
+            return false;
+        }
+        filters.push({
+            operator: "eq",
+            field: propCode,
+            value: entityToSave[propCode],
+        });
+    }
+    const entityInDb = await findEntity(server, dataAccessor, {
+        filters,
+        routeContext,
+    });
+    if (entityId) {
+        return entityInDb && entityInDb.Id !== entityId;
+    }
+    else {
+        return !!entityInDb;
+    }
+}
+function getEntityDuplicatedErrorMessage(server, model, indexConfig) {
+    const propertyNames = indexConfig.properties.map((propConfig) => {
+        let propCode;
+        if (lodash.isString(propConfig)) {
+            propCode = propConfig;
+        }
+        else {
+            propCode = propConfig.code;
+        }
+        const prop = getEntityPropertyByCode(server, model, propCode);
+        return prop.name;
+    });
+    return `已存在 ${propertyNames.join(", ")} 相同的记录。`;
+}
 class EntityManager {
     #server;
     #dataAccessor;
@@ -4056,6 +4251,16 @@ async function syncDatabaseSchema(server, applicationConfig) {
             await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} ADD CONSTRAINT ${queryBuilder.quoteObject(expectedContraintName)} PRIMARY KEY (id);`, []);
         }
     }
+    // generate indexes
+    for (const model of applicationConfig.models) {
+        if (!model.indexes || !model.indexes.length) {
+            continue;
+        }
+        for (const index of model.indexes) {
+            const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
+            await server.tryQueryDatabaseObject(sqlCreateIndex, []);
+        }
+    }
 }
 function generateCreateColumnDDL(queryBuilder, options) {
     let columnDDL = `ALTER TABLE ${queryBuilder.quoteTable(options)} ADD`;
@@ -4088,6 +4293,50 @@ function generateLinkTableDDL(queryBuilder, options) {
     columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null);`;
     return columnDDL;
 }
+function generateTableIndexDDL(queryBuilder, server, model, index) {
+    let indexName = index.name;
+    if (!indexName) {
+        indexName = model.tableName;
+        for (const indexProp of index.properties) {
+            const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
+            const property = getEntityPropertyByCode(server, model, propCode);
+            if (!isRelationProperty(property)) {
+                indexName += "_" + property.columnName;
+            }
+            else if (isOneRelationProperty(property)) {
+                indexName += "_" + property.targetIdColumnName;
+            }
+        }
+        indexName += index.unique ? "_uindex" : "_index";
+    }
+    const indexColumns = lodash.map(index.properties, (indexProp) => {
+        let columnName;
+        const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
+        const property = getEntityPropertyByCode(server, model, propCode);
+        if (!isRelationProperty(property)) {
+            columnName = property.columnName;
+        }
+        else if (isOneRelationProperty(property)) {
+            columnName = property.targetIdColumnName;
+        }
+        if (lodash.isString(indexProp)) {
+            return columnName;
+        }
+        if (indexProp.order === "desc") {
+            return `${columnName} desc`;
+        }
+        return columnName;
+    });
+    let ddl = `CREATE ${index.unique ? "UNIQUE" : ""} INDEX ${indexName} `;
+    ddl += `ON ${queryBuilder.quoteTable({
+        schema: model.schema,
+        tableName: model.tableName,
+    })} (${indexColumns.join(", ")})`;
+    if (index.conditions) {
+        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
+    }
+    return ddl;
+}
 const pgPropertyTypeColumnMap = {
     integer: "int4",
     long: "int8",

package/dist/queryBuilder/queryBuilder.d.ts

@@ -5,6 +5,10 @@ export interface BuildQueryContext {
     builder: QueryBuilder;
     params: any[];
     emitTableAlias: boolean;
+    /**
+     * emit parameter value to sql literal.
+     */
+    paramToLiteral: boolean;
 }
 export interface InitQueryBuilderOptions {
     dbDefaultSchema: string;
@@ -22,5 +26,6 @@ export default class QueryBuilder {
     insert(model: RpdDataModel, options: CreateEntityOptions): DatabaseQuery;
     update(model: RpdDataModel, options: UpdateRowOptions): DatabaseQuery;
     delete(model: RpdDataModel, options: DeleteRowOptions): DatabaseQuery;
+    buildFiltersExpression(model: RpdDataModel, filters: RowFilterOptions[]): string;
 }
 export declare function buildFiltersQuery(ctx: BuildQueryContext, filters: RowFilterOptions[]): string;

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
-import { ColumnSelectOptions, CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
+import { ColumnSelectOptions, CountRowOptions, FindRowOptions, RowFilterOptions } from "./dataAccess/dataAccessTypes";
 export type RapidServerConfig = {
     baseUrl?: string;
     sessionCookieName: string;
@@ -148,6 +148,7 @@ export interface QuoteTableOptions {
 export interface IQueryBuilder {
     quoteTable: (options: QuoteTableOptions) => string;
     quoteObject: (name: string) => string;
+    buildFiltersExpression(model: RpdDataModel, filters: RowFilterOptions[]): any;
 }
 export interface RpdApplicationConfig {
     code?: string;
@@ -180,6 +181,7 @@ export interface RpdDataModel {
      */
     displayPropertyCode?: string;
     properties: RpdDataModelProperty[];
+    indexes?: RpdDataModelIndex[];
     extensions?: RpdDataModelExtension[];
     permissionPolicies?: RpdDataModelPermissionPolicies;
 }
@@ -320,6 +322,17 @@ export interface RpdDataModelExtension {
     code: string;
     config: any;
 }
+export interface RpdDataModelIndex {
+    name?: string;
+    unique?: boolean;
+    properties: RpdDataModelIndexPropertyConfig[];
+    conditions?: RpdDataModelIndexOptions[];
+}
+export type RpdDataModelIndexPropertyConfig = string | {
+    code: string;
+    order?: "asc" | "desc";
+};
+export type RpdDataModelIndexOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityLogicalFilterOptions<RpdDataModelIndexOptions> | FindEntityUnaryFilterOptions;
 export type EventHandler<T = any> = (sender: RapidPlugin, payload: T) => void;
 export interface RpdRoute {
     name: string;
@@ -381,9 +394,9 @@ export interface FindEntitySetFilterOptions {
     value: any[];
     itemType?: string;
 }
-export interface FindEntityLogicalFilterOptions {
+export interface FindEntityLogicalFilterOptions<TFilter = EntityFilterOptions> {
     operator: EntityFilterLogicalOperators;
-    filters: EntityFilterOptions[];
+    filters: TFilter[];
 }
 export interface FindEntityUnaryFilterOptions {
     field: string;
@@ -421,6 +434,7 @@ export interface DeleteEntityByIdOptions {
 export interface CreateEntityOptions {
     routeContext?: RouteContext;
     entity: any;
+    postponeUniquenessCheck?: boolean;
 }
 export interface UpdateEntityOptions {
     routeContext?: RouteContext;
@@ -435,6 +449,7 @@ export interface UpdateEntityByIdOptions {
         type: string;
     };
     stateProperties?: string[];
+    postponeUniquenessCheck?: boolean;
 }
 export interface DeleteEntityOptions {
     routeContext?: RouteContext;

package/package.json

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