@ibiz-template/runtime 0.6.1-dev.0 → 0.6.1-dev.1

package/src/de-logic/de-logic.ts

@@ -1,227 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import { ModelError, RuntimeModelError } from '@ibiz-template/core';
-import { IAppDELogic } from '@ibiz/model-core';
-import { ScriptFactory, ScriptFunction } from '../utils';
-import { DELogicContext } from './de-logic-context';
-import {
-  AppendParamNode,
-  BindParamNode,
-  CopyParamNode,
-  DataSetNode,
-  DEActionNode,
-  DELogicNode,
-  EndNode,
-  PrepareParamNode,
-  RenewParamNode,
-  ResetParamNode,
-  SortParamNode,
-  StartNode,
-} from './de-logic-node';
-import { ThrowExceptionNode } from './de-logic-node/throw-exception-node/throw-exception-node';
-import { DELogicParam } from './de-logic-param/de-logic-param';
-
-/**
- * 界面逻辑
- *
- * @author lxm
- * @date 2023-02-07 16:02:48
- * @export
- * @class DELogic
- */
-export class DELogic {
-  /**
-   * 所有节点实例
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:38
-   * @protected
-   * @type {Map<string, DELogicNode>}
-   */
-  protected nodes: Map<string, DELogicNode> = new Map();
-
-  /**
-   * 所有参数实例
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:25
-   * @protected
-   * @type {Map<string, DELogicParam>}
-   */
-  protected params: Map<string, DELogicParam> = new Map();
-
-  /**
-   * 脚本函数
-   * @author lxm
-   * @date 2023-09-13 04:25:27
-   * @protected
-   * @type {ScriptFunction}
-   */
-  protected scriptFn?: ScriptFunction;
-
-  /**
-   * Creates an instance of DELogic.
-   * @author lxm
-   * @date 2023-02-08 17:02:26
-   * @param {IAppDELogic} model
-   */
-  constructor(protected model: IAppDELogic) {
-    // 脚本代码模式
-    if (model.customCode) {
-      if (!model.scriptCode) {
-        throw new RuntimeModelError(model, '脚本代码模式没有配置脚本代码');
-      }
-      this.scriptFn = ScriptFactory.createScriptFn([], model.scriptCode, {
-        isAsync: true,
-      });
-      return;
-    }
-
-    if (!model.delogicNodes?.length) {
-      throw new RuntimeModelError(model, '实体逻辑没有配置逻辑节点');
-    }
-    model.delogicNodes.forEach(node => {
-      const { logicNodeType } = node;
-      let logicNode;
-      switch (logicNodeType) {
-        case 'BEGIN': // 开始
-          logicNode = new StartNode(node);
-          break;
-        case 'END': // 结束
-          logicNode = new EndNode(node);
-          break;
-        case 'DEACTION': // 实体行为
-          logicNode = new DEActionNode(node);
-          break;
-        case 'PREPAREPARAM': // 准备参数
-          logicNode = new PrepareParamNode(node);
-          break;
-        case 'DEDATASET': // 实体数据集
-          logicNode = new DataSetNode(node);
-          break;
-        case 'THROWEXCEPTION': // 抛出异常
-          logicNode = new ThrowExceptionNode(node);
-          break;
-        case 'BINDPARAM': // 绑定参数
-          logicNode = new BindParamNode(node);
-          break;
-        case 'RESETPARAM': // 重置参数
-          logicNode = new ResetParamNode(node);
-          break;
-        case 'COPYPARAM': // 拷贝参数
-          logicNode = new CopyParamNode(node);
-          break;
-        case 'RENEWPARAM': // 重新建立参数
-          logicNode = new RenewParamNode(node);
-          break;
-        case 'APPENDPARAM': // 附加到数组参数
-          logicNode = new AppendParamNode(node);
-          break;
-        case 'SORTPARAM': // 排序数组参数
-          logicNode = new SortParamNode(node);
-          break;
-        default:
-          throw new ModelError(node, `未支持的逻辑节点类型: ${logicNodeType}`);
-      }
-      this.nodes.set(node.id!, logicNode);
-    });
-    model.delogicParams?.forEach(param => {
-      this.params.set(param.id!, new DELogicParam(param));
-    });
-    // 将已经实例化的逻辑节点挂载到逻辑连接上
-    this.nodes.forEach(node => {
-      node.links.forEach(link => {
-        link.srcNode = node;
-        if (this.nodes.has(link.model.thenId!)) {
-          link.dstNode = this.nodes.get(link.model.thenId!)!;
-        }
-      });
-    });
-  }
-
-  /**
-   * 初始化当前环境的逻辑参数的实例
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:58
-   * @protected
-   * @param {DELogicContext} ctx
-   * @param {IContext} context
-   * @param {IData} data
-   * @param {IParams} [opt]
-   */
-  protected initLogicParams(ctx: DELogicContext): void {
-    this.params.forEach(param => {
-      if (param.model.default) {
-        ctx.defaultParamName = param.model.id!;
-      }
-      param.calc(ctx);
-    });
-  }
-
-  /**
-   * 执行逻辑
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:09
-   * @param {IContext} context
-   * @param {IData} data
-   * @param {IParams} [opt]
-   * @return {*}  {Promise<IData>}
-   */
-  async exec(
-    context: IContext,
-    data: IData | IData[],
-    params: IParams,
-  ): Promise<unknown> {
-    if (this.scriptFn) {
-      return this.scriptFn.exec({ context, data, params });
-    }
-    const ctx = new DELogicContext(this.params, context, data, params);
-    this.initLogicParams(ctx);
-    const { startDELogicNodeId } = this.model;
-    if (startDELogicNodeId && this.nodes.has(startDELogicNodeId)) {
-      const start = this.nodes.get(startDELogicNodeId)!;
-      await this.deepExec(start, ctx);
-    } else {
-      throw new RuntimeModelError(this.model, `未设置起始节点`);
-    }
-    if (ctx.isEndNode) {
-      return ctx.result;
-    }
-    if (ctx.params[ctx.defaultParamName]) {
-      return ctx.params[ctx.defaultParamName];
-    }
-    return null;
-  }
-
-  /**
-   * 开始根据连线递归执行逻辑
-   *
-   * @author lxm
-   * @date 2023-06-13 08:29:36
-   * @protected
-   * @param {DELogicNode} node 逻辑节点
-   * @param {DELogicContext} ctx 逻辑上下文
-   * @return {*}  {Promise<void>}
-   */
-  protected async deepExec(
-    node: DELogicNode,
-    ctx: DELogicContext,
-  ): Promise<void> {
-    // 执行逻辑节点
-    await node.exec(ctx);
-    const { links } = node;
-    // 遍历所有节点连接，递归执行下级连接节点
-    for (let index = 0; index < links.length; index++) {
-      const link = links[index];
-      const bol = await link.exec(ctx);
-      if (bol && link.dstNode) {
-        await this.deepExec(link.dstNode, ctx);
-        // 平行输出: 在满足连接条件并逻辑执行完毕后若是非平行输出则执行完成
-        if (node.model.parallelOutput === false) {
-          break;
-        }
-      }
-    }
-  }
-}

package/src/de-logic/index.ts

@@ -1,185 +0,0 @@
-import { HttpError, HttpResponse, RuntimeError } from '@ibiz-template/core';
-import { IAppDataEntity, IAppDELogic } from '@ibiz/model-core';
-import { isArray } from 'lodash-es';
-import { clone } from 'ramda';
-import { filterFieldLogics, findDELogic } from '../model';
-import { DELogic } from './de-logic';
-
-/**
- * 实体处理逻辑实例缓存
- */
-const deLogicMap: WeakMap<IAppDELogic, DELogic> = new Map();
-
-/**
- * 找到实体逻辑模型
- * @author lxm
- * @date 2023-08-04 02:47:16
- * @param {string} deDELogicId
- * @param {string} dataEntityId
- * @param {string} [appId]
- * @return {*}  {(Promise<IAppDELogic | undefined>)}
- */
-async function findDeLogic(
-  deDELogicId: string,
-  dataEntityId: string,
-  appId: string,
-): Promise<IAppDELogic | undefined> {
-  const appDataEntity = await ibiz.hub.getAppDataEntity(dataEntityId, appId);
-  return findDELogic(deDELogicId, appDataEntity);
-}
-
-/**
- * 执行实体处理逻辑
- *
- * @author lxm
- * @date 2023-02-09 11:02:23
- * @export
- * @param {IAppDELogic} deDELogic
- * @param {IContext} context
- * @param {(IData)} data
- * @param {IParams} params
- * @param {IParams} [opt]
- * @return {*}  {Promise<HttpResponse<IData>>}
- */
-export async function execDELogic(
-  deDELogic: IAppDELogic,
-  context: IContext,
-  data: IData | IData[] = {},
-  params: IParams = {},
-): Promise<unknown> {
-  if (!deLogicMap.has(deDELogic)) {
-    deLogicMap.set(deDELogic, new DELogic(deDELogic));
-  }
-
-  const deLogic = deLogicMap.get(deDELogic)!;
-  return deLogic.exec(context, data, params);
-}
-
-/**
- * 通过id执行实体逻辑
- * @author lxm
- * @date 2023-08-04 02:49:44
- * @export
- * @param {string} deDELogicId
- * @param {string} dataEntityId
- * @param {IContext} context
- * @param {IData} data
- * @param {IParams} params
- * @return {*}  {Promise<unknown>}
- */
-export async function execDELogicById(
-  deDELogicId: string,
-  dataEntityId: string,
-  context: IContext,
-  data: IData,
-  params: IParams,
-): Promise<unknown> {
-  const deLogic = await findDeLogic(
-    deDELogicId,
-    dataEntityId,
-    context.srfappid,
-  );
-  if (!deLogic) {
-    throw new RuntimeError(`${dataEntityId}找不到实体逻辑${deDELogicId}`);
-  }
-  return execDELogic(deLogic, context, data, params);
-}
-
-/**
- * 执行实体方法的实体逻辑并返回对应的response
- * @author lxm
- * @date 2023-03-16 12:44:43
- * @export
- * @param {IAppDELogic} deDELogic
- * @param {IContext} context
- * @param {(IData)} data
- * @param {IParams} params
- * @param {IParams} [opt]
- * @return {*}  {Promise<HttpResponse<IData>>}
- */
-export async function execDELogicAction(
-  deDELogic: IAppDELogic,
-  context: IContext,
-  data?: IData | IData[],
-  params?: IParams,
-): Promise<HttpResponse<IData>> {
-  const _context = clone(context);
-  const _data = data ? clone(data) : data;
-  const _params = params ? clone(params) : params;
-
-  try {
-    const result = await execDELogic(deDELogic, _context, _data, _params);
-    return new HttpResponse(result);
-  } catch (err) {
-    if (err instanceof HttpError) {
-      return new HttpResponse(err, 500);
-    }
-    throw err;
-  }
-}
-
-/**
- * 执行属性实体逻辑（单条数据）
- * @author lxm
- * @date 2023-10-19 04:00:15
- * @export
- * @param {IAppDataEntity} entity
- * @param {('compute' | 'change' | 'default')} type
- * @param {IContext} context
- * @param {IData} data
- * @param {IParams} params
- * @return {*}  {Promise<void>}
- */
-async function execSingleFieldLogics(
-  entity: IAppDataEntity,
-  type: 'compute' | 'change' | 'default',
-  context: IContext,
-  data: IData,
-  params: IParams,
-): Promise<void> {
-  const fieldLogics = filterFieldLogics(entity, type);
-  if (fieldLogics.length) {
-    const promiseResult = await Promise.all(
-      fieldLogics.map(logic => {
-        return execDELogic(logic, context, data, params);
-      }),
-    );
-    promiseResult.forEach(value => {
-      Object.assign(data, value);
-    });
-  }
-}
-
-/**
- * 执行属性实体逻辑(单条或者多条)
- * @author lxm
- * @date 2023-06-14 12:29:56
- * @export
- * @param {IAppDataEntity} entity
- * @param {('compute' | 'change' | 'default')} type
- * @param {IContext} context
- * @param {IData | IData[]} data 单条或多条数据
- * @param {IParams} params
- * @return {*}  {Promise<void>}
- */
-export async function execFieldLogics(
-  entity: IAppDataEntity,
-  type: 'compute' | 'change' | 'default',
-  context: IContext,
-  data: IData | IData[],
-  params: IParams = {},
-): Promise<void> {
-  if (!data) {
-    return;
-  }
-
-  if (isArray(data)) {
-    await Promise.all(
-      data.map(item =>
-        execSingleFieldLogics(entity, type, context, item, params),
-      ),
-    );
-    return;
-  }
-  return execSingleFieldLogics(entity, type, context, data, params);
-}

package/src/de-logic/utils/handle-src-val.ts

@@ -1,130 +0,0 @@
-import { ModelError } from '@ibiz-template/core';
-import { clone } from 'ramda';
-import { ScriptFactory } from '../../utils';
-import { DELogicContext } from '../de-logic-context';
-
-type SrcValParams = {
-  /**
-   * 源值类型
-   */
-  srcValueType?: string;
-  /**
-   * 源属性名称
-   */
-  srcFieldName?: string;
-  /**
-   * 直接值
-   */
-  srcValue?: string;
-  /**
-   * 源参数对象id
-   */
-  srcDELogicParamId?: string;
-
-  /**
-   * 目标逻辑参数
-   *
-   */
-  dstDELogicParamId?: string;
-
-  /**
-   * 目标属性名称
-   *
-   */
-  dstFieldName?: string;
-
-  /**
-   * 表达式
-   *
-   */
-  expression?: string;
-};
-
-/**
- * 解析模型并获取源参数或其中的某个属性
- * @author lxm
- * @date 2023-06-13 11:20:39
- * @export
- * @param {SrcValParams} srcValParams
- * @param {DELogicContext} ctx
- * @return {*}
- */
-export function handleSrcVal(
-  ctx: DELogicContext,
-  srcValParams: SrcValParams,
-): unknown {
-  const { srcDELogicParamId, srcFieldName, srcValue, expression } =
-    srcValParams;
-  // 没有源值类型就是逻辑参数
-  const srcValueType = srcValParams.srcValueType || 'SRCDLPARAM';
-  // 取属性值
-  let srcField = srcFieldName;
-
-  let value: unknown;
-  switch (srcValueType) {
-    // 源逻辑参数
-    case 'SRCDLPARAM':
-      value = ctx.params[srcDELogicParamId!];
-      // 如果是实体参数对象则转换成小写。
-      if (ctx.isEntityParam(srcDELogicParamId!)) {
-        srcField = srcField?.toLowerCase();
-      }
-      break;
-    // 空值类型
-    case 'NULLVALUE':
-      return null;
-    // 无值类型
-    case 'NONEVALUE':
-      return undefined;
-    // 直接值
-    case 'SRCVALUE':
-      return ibiz.util.rawValue.format(srcValue);
-    case 'WEBCONTEXT': // 网页请求上下文
-    case 'VIEWPARAM': // 视图参数
-      value = ctx.parameters.params;
-      break;
-    case 'APPLICATION': // 系统全局对象
-    case 'SESSION': // 用户全局对象
-    case 'APPDATA': // 应用上下文
-    case 'DATACONTEXT': // 数据上下文
-      value = ctx.parameters.context;
-      break;
-    // 当前环境参数
-    case 'ENVPARAM':
-      value = clone(ibiz.env);
-      break;
-    case 'EXPRESSION':
-      if (!expression) {
-        throw new ModelError(srcValParams, `表达式为空`);
-      }
-      value = ScriptFactory.execScriptFn(ctx, expression!, {
-        singleRowReturn: true,
-        isAsync: false,
-      });
-      break;
-    default:
-      throw new ModelError(srcValParams, `暂未支持源值类型${srcValueType}`);
-  }
-
-  if (value && srcField) {
-    try {
-      if (Array.isArray(value)) {
-        value = value[Number(srcField)];
-      } else {
-        value = ScriptFactory.execScriptFn(
-          { srcValue: value },
-          `srcValue.${srcField}`,
-          {
-            singleRowReturn: true,
-            isAsync: false,
-          },
-        );
-      }
-    } catch (error) {
-      ibiz.log.error(`从源参数取属性${srcField}报错，源参数：`, value);
-      throw error;
-    }
-  }
-
-  return value;
-}

package/src/de-logic/utils/index.ts

@@ -1 +0,0 @@
-export * from './handle-src-val';

package/src/engine/engine-factory.ts

@@ -1,67 +0,0 @@
-import { IAppViewEngine } from '@ibiz/model-core';
-import { IViewEngine } from '../interface/engine';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type NewEngine = (...args: any[]) => IViewEngine;
-
-/**
- * 引擎工厂
- * @author lxm
- * @date 2023-04-25 07:17:42
- * @export
- * @class EngineFactory
- */
-export class EngineFactory {
-  /**
-   * 视图引擎classMap
-   * @author lxm
-   * @date 2023-04-25 07:28:36
-   * @protected
-   */
-  protected viewEngines = new Map<string, NewEngine>();
-
-  /**
-   * 注册视图引擎
-   * @author lxm
-   * @date 2023-04-25 07:40:23
-   * @param {string} key
-   * @param {IViewEngine} engine
-   */
-  register(key: string, engine: NewEngine): void {
-    this.viewEngines.set(key, engine);
-  }
-
-  /**
-   * 注销视图引擎
-   * @author lxm
-   * @date 2023-04-25 07:40:32
-   * @param {string} key
-   */
-  unRegister(key: string): void {
-    this.viewEngines.delete(key);
-  }
-
-  /**
-   * 获取视图引擎
-   * @author lxm
-   * @date 2023-05-04 02:26:34
-   * @param {IAppView} model
-   * @param {IViewController} viewController 视图控制器
-   * @return {*}  {(ViewEngine | undefined)}
-   */
-  getEngine(
-    model: IAppViewEngine,
-    ...args: Parameters<NewEngine>
-  ): IViewEngine | undefined {
-    const { engineType, engineCat } = model;
-
-    const key = `${engineCat}_${engineType}`;
-    const func = this.viewEngines.get(key);
-
-    // 存在则执行，生成对象
-    if (func) {
-      return func(...args);
-    }
-    ibiz.log.error(`没有${key}对应的引擎`, model);
-  }
-}

package/src/engine/index.ts

@@ -1,3 +0,0 @@
-export * from './engine-factory';
-export * from './view-base.engine';
-export * from './md-view.engine';