@ddd-tool/domain-designer-cli 0.1.0-beta.9 → 0.3.1

package/packages/playground/src/views/complex-example-detail/user.ts

@@ -0,0 +1,66 @@
+import { i, d } from './common'
+
+export const userValues = {
+  用户id: i.id('userId'),
+  逾期次数: i.valueObj('overdueTimes', '正整数，每当用户有逾期行为，自增1'),
+  是否暂停: i.valueObj('isSuspended'),
+} as const
+
+export const 管理员 = d.actor('管理员')
+export const 会员 = d.actor('会员')
+export const 定时器 = d.actor('定时器')
+
+const 会员账户已暂停 = d.event('UserAccountSuspended', ['userId'], '会员账户已暂停')
+
+const 会员账户已启用 = d.event('UserAccountResumed', ['userId'], '会员账户已启用')
+
+const 启用会员账户 = d.command(
+  'ResumeAccount',
+  ['userId'],
+  d.note`启用会员账户
+    1.会员账户当前被暂停才能启用`,
+)
+
+export const 用户聚合 = d.agg('userAgg', [
+  userValues.用户id,
+  userValues.是否暂停,
+  userValues.逾期次数,
+])
+
+const 会员外部系统 = d.system('UserSystem', '会员外部系统')
+
+const 会员账号已创建 = d.event(
+  'UserAccountCreatedEvt',
+  ['会员id : userId', '会员名'],
+  '会员账号已创建',
+)
+
+export const 会员账号读模型 = d.readModel(
+  'UserAccountStatsRM',
+  ['会员id : userId', '会员名', '是否暂停', '累计逾期次数'],
+  '会员账号读模型',
+)
+
+const 增加逾期次数 = d.command(
+  'IncreaseAccountTimeOutCount',
+  [userValues.用户id],
+  d.note`增加逾期次数
+    1.会员累计逾期达到3次暂停账户
+    2.会员账户当前是启用才能被暂停`,
+)
+
+// ============================= 流程定义 =============================
+
+const 创建会员流程 = d.startWorkflow('创建会员流程')
+会员外部系统.event(会员账号已创建).readModel(会员账号读模型)
+
+const 暂停会员流程 = d.startWorkflow('暂停会员流程')
+用户聚合.event(会员账户已暂停).readModel(会员账号读模型)
+
+const 启动会员流程 = d.startWorkflow('启动会员流程')
+管理员.command(启用会员账户).agg(用户聚合).event(会员账户已启用).readModel(会员账号读模型)
+
+const 增加逾期次数流程 = d.startWorkflow('增加逾期次数流程')
+管理员.command(增加逾期次数).agg(用户聚合)
+
+d.defineUserStory('会员管理', [创建会员流程, 暂停会员流程, 启动会员流程, 增加逾期次数流程])

package/packages/playground/src/views/complex-example.ts

@@ -0,0 +1,4 @@
+import { d } from './complex-example-detail/common'
+import './complex-example-detail/user'
+import './complex-example-detail/book'
+export default d

package/{src → packages/playground/src}/views/design-en.ts

@@ -1,99 +1,110 @@
-import { createDomainDesigner } from '@ddd-tool/domain-designer-core'
-
-const d = createDomainDesigner()
-const i = d.info
-
-// user
-const user = d.actor('user', 'order user')
-
-// aggregation
-const userAccount = i.valueObj('userAccount')
-const orderId = i.id('orderId')
-const orderTime = i.valueObj('orderTime')
-const productPrice = i.valueObj('productPrice')
-const productQuantity = i.valueObj('productQuantity')
-const orderAmount = d.info.func('orderAmount', [productPrice, productQuantity])
-const orderAggregation = d.agg(
-  'orderAggregation',
-  [orderId, orderTime, userAccount, productPrice, productQuantity, orderAmount],
-  'this is order aggregation'
-)
-
-// command
-const createOrder = d.command('createOrder', [orderAggregation.inner.orderId, userAccount])
-const autoDeduct = d.command('autoDeduct', [orderId])
-
-// event
-const orderSuccess = d.event('orderSuccess', [orderId, orderTime])
-const orderFailure = d.event('orderFailure', [orderId, orderTime])
-const deductSuccess = d.event('deductSuccess', [orderId, orderTime])
-const deductFailure = d.event('deductFailure', [orderId, orderTime])
-// rule
-const paymentRule = d.policy(
-  'paymentRule',
-  d.desc`
-if ${userAccount} has opened the automatic payment service, then automatic payment is initiated
-rule 1:
-rule 2:
-rule 3:
-... ...
-  `
-)
-// service
-const autoDeductService = d.service('autoDeductService', 'initiate automatic payment based on payment rule')
-// external system
-const logisticsSystem = d.system('logisticsSystem')
-const mailSystem = d.system('mailSystem')
-
-// read model
-const orderDetail = d.readModel('orderDetailReadModel', [orderId, orderTime])
-
-const createOrderFailureWorkflow = d.startWorkflow('createOrderFailure')
-user.command(createOrder).agg(orderAggregation).event(orderFailure)
-orderFailure.system(mailSystem)
-
-const createOrderSuccess_AutoDeductFailureWorkflow = d.startWorkflow('createOrderSuccess_AutoDeductFailure')
-user
-  .command(createOrder)
-  .agg(orderAggregation)
-  .event(orderSuccess)
-  .policy(paymentRule)
-  .service(autoDeductService)
-  .command(autoDeduct)
-  .agg(orderAggregation)
-  .event(deductFailure)
-deductFailure.readModel(orderDetail)
-deductFailure.system(mailSystem)
-
-const createOrderSuccess_AutoDeductSuccessWorkflow = d.startWorkflow('createOrderSuccess_AutoDeductSuccess')
-user
-  .command(createOrder)
-  .agg(orderAggregation)
-  .event(orderSuccess)
-  .policy(paymentRule)
-  .service(autoDeductService)
-  .command(autoDeduct)
-  .agg(orderAggregation)
-  .event(deductSuccess)
-deductSuccess.readModel(orderDetail)
-deductSuccess.system(logisticsSystem)
-
-d.startWorkflow('unclassifiedWorkflow')
-user.command(createOrder).agg(orderAggregation).event(orderFailure)
-orderFailure.system(mailSystem)
-
-d.startWorkflow('readModel')
-const userRead = d.actor('user', 'user (read model)')
-userRead.readModel(orderDetail)
-
-d.defineUserStory('as a mall user, I want to place an order and implement automatic payment to get the goods', [
-  createOrderFailureWorkflow,
-  createOrderSuccess_AutoDeductFailureWorkflow,
-  createOrderSuccess_AutoDeductSuccessWorkflow,
-])
-
-d.defineUserStory('as a mall user, I want to view the order status, so I can know the order status', [
-  createOrderSuccess_AutoDeductSuccessWorkflow,
-])
-
-export default d
+import { createDomainDesigner } from '@ddd-tool/domain-designer-core'
+
+const d = createDomainDesigner()
+const i = d.info
+
+// user
+const user = d.actor('user', 'order user')
+
+// aggregation
+const userAccount = i.valueObj('userAccount')
+const orderId = i.id('orderId')
+const orderTime = i.valueObj('orderTime')
+const productPrice = i.valueObj('productPrice')
+const productQuantity = i.valueObj('productQuantity')
+const orderAmount = d.info.func('orderAmount', [productPrice, productQuantity])
+const orderAggregation = d.agg(
+  'orderAggregation',
+  [orderId, orderTime, userAccount, productPrice, productQuantity, orderAmount],
+  'this is order aggregation',
+)
+
+// command
+const createOrder = d.command('createOrder', [orderAggregation.inner.orderId, userAccount])
+const autoDeduct = d.command('autoDeduct', [orderId])
+
+// event
+const orderSuccess = d.event('orderSuccess', [orderId, orderTime])
+const orderFailure = d.event('orderFailure', [orderId, orderTime])
+const deductSuccess = d.event('deductSuccess', [orderId, orderTime])
+const deductFailure = d.event('deductFailure', [orderId, orderTime])
+// rule
+const paymentRule = d.policy(
+  'paymentRule',
+  d.note`
+if ${userAccount} has opened the automatic payment service, then automatic payment is initiated
+rule 1:
+rule 2:
+rule 3:
+... ...
+  `,
+)
+// service
+const autoDeductService = d.service(
+  'autoDeductService',
+  'initiate automatic payment based on payment rule',
+)
+// external system
+const logisticsSystem = d.system('logisticsSystem')
+const mailSystem = d.system('mailSystem')
+
+// read model
+const orderDetail = d.readModel('orderDetailReadModel', [orderId, orderTime])
+
+const createOrderFailureWorkflow = d.startWorkflow('createOrderFailure')
+user.command(createOrder).agg(orderAggregation).event(orderFailure)
+orderFailure.system(mailSystem)
+
+const createOrderSuccess_AutoDeductFailureWorkflow = d.startWorkflow(
+  'createOrderSuccess_AutoDeductFailure',
+)
+user
+  .command(createOrder)
+  .agg(orderAggregation)
+  .event(orderSuccess)
+  .policy(paymentRule)
+  .service(autoDeductService)
+  .command(autoDeduct)
+  .agg(orderAggregation)
+  .event(deductFailure)
+deductFailure.readModel(orderDetail)
+deductFailure.system(mailSystem)
+
+const createOrderSuccess_AutoDeductSuccessWorkflow = d.startWorkflow(
+  'createOrderSuccess_AutoDeductSuccess',
+)
+user
+  .command(createOrder)
+  .agg(orderAggregation)
+  .event(orderSuccess)
+  .policy(paymentRule)
+  .service(autoDeductService)
+  .command(autoDeduct)
+  .agg(orderAggregation)
+  .event(deductSuccess)
+deductSuccess.readModel(orderDetail)
+deductSuccess.system(logisticsSystem)
+
+d.startWorkflow('unclassifiedWorkflow')
+user.command(createOrder).agg(orderAggregation).event(orderFailure)
+orderFailure.system(mailSystem)
+
+d.startWorkflow('readModel')
+const userRead = d.actor('user', 'user (read model)')
+userRead.readModel(orderDetail)
+
+d.defineUserStory(
+  'as a mall user, I want to place an order and implement automatic payment to get the goods',
+  [
+    createOrderFailureWorkflow,
+    createOrderSuccess_AutoDeductFailureWorkflow,
+    createOrderSuccess_AutoDeductSuccessWorkflow,
+  ],
+)
+
+d.defineUserStory(
+  'as a mall user, I want to view the order status, so I can know the order status',
+  [createOrderSuccess_AutoDeductSuccessWorkflow],
+)
+
+export default d

package/{src → packages/playground/src}/views/design-zh.ts

@@ -1,91 +1,97 @@
-import { createDomainDesigner } from '@ddd-tool/domain-designer-core'
-
-const d = createDomainDesigner()
-const i = d.info
-
-// 用户
-const 用户 = d.actor('用户', '下单用户')
-
-// 聚合
-const 用户账号 = i.valueObj('用户账号')
-const 订单号 = i.id('订单号')
-const 下单时间 = i.valueObj('下单时间')
-const 商品价格 = i.valueObj('商品价格')
-const 商品数量 = i.valueObj('商品数量')
-const 订单金额 = d.info.func('订单金额', [商品价格, 商品数量])
-const 订单聚合 = d.agg('订单聚合', [订单号, 下单时间, 用户账号, 商品价格, 商品数量, 订单金额], '这是订单聚合')
-
-// 命令
-const 创建订单 = d.command('创建订单', [订单聚合.inner.订单号, 用户账号])
-const 自动扣款 = d.command('自动扣款', [订单号])
-
-// 事件
-const 下单成功 = d.event('下单成功', [订单号, 下单时间])
-const 下单失败 = d.event('下单失败', [订单号, 下单时间])
-const 扣款成功 = d.event('扣款成功', [订单号, 下单时间])
-const 扣款失败 = d.event('扣款失败', [订单号, 下单时间])
-// 规则
-const 付款规则 = d.policy(
-  '付款规则',
-  d.desc`
-如果${用户账号}开通了自动扣费服务，则发起自动扣款
-规则1：
-规则2：
-规则3：
-... ...
-  `
-)
-// 服务
-const 自动扣款服务 = d.service('自动扣款服务', '根据付款规则发起自动扣款')
-// 外部系统
-const 物流系统 = d.system('物流系统')
-const 邮件系统 = d.system('邮件系统')
-
-// 读模型
-const 订单详情 = d.readModel('订单详情读模型', [订单号, 下单时间])
-
-const 创建订单失败流程 = d.startWorkflow('创建订单失败')
-用户.command(创建订单).agg(订单聚合).event(下单失败)
-下单失败.system(邮件系统)
-
-const 创建订单成功_自动扣款失败流程 = d.startWorkflow('创建订单成功，自动扣款失败')
-用户.command(创建订单)
-  .agg(订单聚合)
-  .event(下单成功)
-  .policy(付款规则)
-  .service(自动扣款服务)
-  .command(自动扣款)
-  .agg(订单聚合)
-  .event(扣款失败)
-扣款失败.readModel(订单详情)
-扣款失败.system(邮件系统)
-
-const 创建订单成功_自动扣款成功流程 = d.startWorkflow('创建订单成功，自动扣款成功')
-用户.command(创建订单)
-  .agg(订单聚合)
-  .event(下单成功)
-  .policy(付款规则)
-  .service(自动扣款服务)
-  .command(自动扣款)
-  .agg(订单聚合)
-  .event(扣款成功)
-扣款成功.readModel(订单详情)
-扣款成功.system(物流系统)
-
-d.startWorkflow('未归纳流程')
-用户.command(创建订单).agg(订单聚合).event(下单失败)
-下单失败.system(邮件系统)
-
-d.startWorkflow('读模型')
-const 用户读 = d.actor('用户', '用户(读模型)')
-用户读.readModel(订单详情)
-
-d.defineUserStory('作为商城用户，我要下单并且实现自动扣款，以便购得心仪得商品', [
-  创建订单失败流程,
-  创建订单成功_自动扣款失败流程,
-  创建订单成功_自动扣款成功流程,
-])
-
-d.defineUserStory('作为商城用户，我要查看订单情况，以便了解订单状态', [创建订单成功_自动扣款成功流程])
-
-export default d
+import { createDomainDesigner } from '@ddd-tool/domain-designer-core'
+
+const d = createDomainDesigner()
+const i = d.info
+
+// 用户
+const 用户 = d.actor('用户', '下单用户')
+
+// 聚合
+const 用户账号 = i.valueObj('用户账号')
+const 订单号 = i.id('订单号')
+const 下单时间 = i.valueObj('下单时间')
+const 商品价格 = i.valueObj('商品价格')
+const 商品数量 = i.valueObj('商品数量')
+const 订单金额 = d.info.func('订单金额', [商品价格, 商品数量])
+const 订单聚合 = d.agg(
+  '订单聚合',
+  [订单号, 下单时间, 用户账号, 商品价格, 商品数量, 订单金额],
+  '这是订单聚合',
+)
+
+// 命令
+const 创建订单 = d.command('创建订单', [订单聚合.inner.订单号, 用户账号])
+const 自动扣款 = d.command('自动扣款', [订单号])
+
+// 事件
+const 下单成功 = d.event('下单成功', [订单号, 下单时间])
+const 下单失败 = d.event('下单失败', [订单号, 下单时间])
+const 扣款成功 = d.event('扣款成功', [订单号, 下单时间])
+const 扣款失败 = d.event('扣款失败', [订单号, 下单时间])
+// 规则
+const 付款规则 = d.policy(
+  '付款规则',
+  d.note`
+如果${用户账号}开通了自动扣费服务，则发起自动扣款
+规则1：
+规则2：
+规则3：
+... ...
+  `,
+)
+// 服务
+const 自动扣款服务 = d.service('自动扣款服务', '根据付款规则发起自动扣款')
+// 外部系统
+const 物流系统 = d.system('物流系统')
+const 邮件系统 = d.system('邮件系统')
+
+// 读模型
+const 订单详情 = d.readModel('订单详情读模型', [订单号, 下单时间])
+
+const 创建订单失败流程 = d.startWorkflow('创建订单失败')
+用户.command(创建订单).agg(订单聚合).event(下单失败)
+下单失败.system(邮件系统)
+
+const 创建订单成功_自动扣款失败流程 = d.startWorkflow('创建订单成功，自动扣款失败')
+用户.command(创建订单)
+  .agg(订单聚合)
+  .event(下单成功)
+  .policy(付款规则)
+  .service(自动扣款服务)
+  .command(自动扣款)
+  .agg(订单聚合)
+  .event(扣款失败)
+扣款失败.readModel(订单详情)
+扣款失败.system(邮件系统)
+
+const 创建订单成功_自动扣款成功流程 = d.startWorkflow('创建订单成功，自动扣款成功')
+用户.command(创建订单)
+  .agg(订单聚合)
+  .event(下单成功)
+  .policy(付款规则)
+  .service(自动扣款服务)
+  .command(自动扣款)
+  .agg(订单聚合)
+  .event(扣款成功)
+扣款成功.readModel(订单详情)
+扣款成功.system(物流系统)
+
+d.startWorkflow('未归纳流程')
+用户.command(创建订单).agg(订单聚合).event(下单失败)
+下单失败.system(邮件系统)
+
+d.startWorkflow('读模型')
+const 用户读 = d.actor('用户', '用户(读模型)')
+用户读.readModel(订单详情)
+
+d.defineUserStory('作为商城用户，我要下单并且实现自动扣款，以便购得心仪得商品', [
+  创建订单失败流程,
+  创建订单成功_自动扣款失败流程,
+  创建订单成功_自动扣款成功流程,
+])
+
+d.defineUserStory('作为商城用户，我要查看订单情况，以便了解订单状态', [
+  创建订单成功_自动扣款成功流程,
+])
+
+export default d

package/packages/playground/src/views/index.ts

@@ -0,0 +1,19 @@
+import { type DomainDesigner, isDomainDesigner } from '@ddd-tool/domain-designer-core'
+
+const __d1 = (
+  await import('F:/vscode_projects/@ddd-tool/domain-designer-cli-node/demo/complex-example')
+).default
+const __d2 = (
+  await import('F:/vscode_projects/@ddd-tool/domain-designer-cli-node/demo/simple-example')
+).default
+
+const data: Record<string, DomainDesigner> = {}
+
+if (isDomainDesigner(__d1)) {
+  data['complex-example'] = __d1
+}
+if (isDomainDesigner(__d2)) {
+  data['simple-example'] = __d2
+}
+
+export default data

package/packages/playground/src/views/simple-example.ts

@@ -0,0 +1,103 @@
+import { createDomainDesigner } from '@ddd-tool/domain-designer-core'
+
+const d = createDomainDesigner()
+const i = d.info
+
+const 用户账号 = i.valueObj('用户账号')
+const 订单号 = i.id('订单号')
+const 下单时间 = i.valueObj('下单时间')
+
+// 事件
+const 下单成功 = d.event('下单成功', [订单号, 下单时间])
+const 下单失败 = d.event('下单失败', [订单号, 下单时间])
+const 扣款成功 = d.event('扣款成功', [订单号, 下单时间])
+const 扣款失败 = d.event('扣款失败', [订单号, 下单时间])
+
+// 命令
+const 创建订单 = d.command('创建订单', [订单号, 用户账号])
+const 自动扣款 = d.command('自动扣款', [订单号])
+
+// 用户
+const 用户 = d.actor('用户', '下单用户')
+
+// 聚合
+const 订单聚合 = d.agg(
+  '订单聚合',
+  [
+    订单号,
+    下单时间,
+    用户账号,
+    '商品价格',
+    '商品数量',
+    d.info.func('订单金额', ['商品价格', '商品数量']),
+  ],
+  '这是订单聚合',
+)
+
+// 规则
+const 付款规则 = d.policy(
+  '付款规则',
+  d.note`
+如果${用户账号}开通了自动扣费服务，则发起自动扣款
+规则1：
+规则2：
+规则3：
+... ...
+  `,
+)
+// 服务
+const 自动扣款服务 = d.service('自动扣款服务', '根据付款规则发起自动扣款')
+// 外部系统
+const 物流系统 = d.system('物流系统')
+const 邮件系统 = d.system('邮件系统')
+
+// 读模型
+const 订单详情 = d.readModel('订单详情读模型', [订单号, 下单时间])
+
+const 创建订单失败流程 = d.startWorkflow('创建订单失败')
+用户.command(创建订单).agg(订单聚合).event(下单失败)
+下单失败.system(邮件系统)
+
+const 创建订单成功_自动扣款失败流程 = d.startWorkflow('创建订单成功，自动扣款失败')
+用户.command(创建订单)
+  .agg(订单聚合)
+  .event(下单成功)
+  .policy(付款规则)
+  .service(自动扣款服务)
+  .command(自动扣款)
+  .agg(订单聚合)
+  .event(扣款失败)
+扣款失败.readModel(订单详情)
+扣款失败.system(邮件系统)
+
+const 创建订单成功_自动扣款成功流程 = d.startWorkflow('创建订单成功，自动扣款成功')
+用户.command(创建订单)
+  .agg(订单聚合)
+  .event(下单成功)
+  .policy(付款规则)
+  .service(自动扣款服务)
+  .command(自动扣款)
+  .agg(订单聚合)
+  .event(扣款成功)
+扣款成功.readModel(订单详情)
+扣款成功.system(物流系统)
+
+d.startWorkflow('未归纳流程')
+用户.command(创建订单).agg(订单聚合).event(下单失败)
+下单失败.system(邮件系统)
+
+d.startWorkflow('读模型相关流程')
+const 用户读 = d.actor('用户', '用户(读模型)')
+用户读.readModel(订单详情)
+
+d.defineUserStory('作为商城用户，我要下单并且实现自动扣款，以便购得心仪得商品', [
+  创建订单失败流程,
+  创建订单成功_自动扣款失败流程,
+  创建订单成功_自动扣款成功流程,
+])
+
+d.defineUserStory('作为商城用户，我要查看订单情况，以便了解订单状态', [
+  创建订单成功_自动扣款成功流程,
+])
+
+export default d

package/packages/playground/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "include": [
+    "src/*",
+    "src/**/*",
+    "__tests__",
+    "scripts",
+    "vite-env.d.ts"
+  ],
+  "compilerOptions": {
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "target": "ESNext",
+    "esModuleInterop": true,
+    "noEmit": true,
+    "sourceMap": true,
+    "lib": [
+      "DOM"
+    ],
+    "types": [
+      "node"
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@ddd-tool/domain-designer-core": [
+        "./node_modules/@ddd-tool/domain-designer-core"
+      ]
+    }
+  }
+}

package/packages/playground/vite-env.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_DESIGNER_PATHS: string
+  // 更多环境变量...
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+interface ViteEnv extends ImportMetaEnv {}

package/packages/playground/vite.config.ts

@@ -0,0 +1,22 @@
+import { fileURLToPath, URL } from 'node:url'
+
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import vueDevTools from 'vite-plugin-vue-devtools'
+
+export default defineConfig({
+  plugins: [vue(), vueDevTools()],
+  esbuild: {
+    drop: ['console', 'debugger'], // 移除 console 和 debugger 语句
+  },
+  dev: {},
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./src', import.meta.url)),
+      '@ddd-tool/domain-designer-core': fileURLToPath(new URL('../core/dist', import.meta.url)),
+      '@ddd-tool/domain-designer-ui-component': fileURLToPath(
+        new URL('../ui-component/dist', import.meta.url),
+      ),
+    },
+  },
+})