cabloy 5.1.120 → 5.1.122

package/vona/src/suite/a-commerce/modules/commerce-trade/test/shipmentRefundRace.test.ts

@@ -31,8 +31,8 @@ async function cleanup(fixture: IFixture) {
   }
 }
 
-async function createPaidOrder(suffix: string): Promise<IFixture> {
-  const fixture: IFixture = { customerName: `shipment-refund-${suffix}` };
+async function createPaidOrder(fixture: IFixture, suffix: string): Promise<void> {
+  fixture.customerName = `shipment-refund-${suffix}`;
   const customer = await app.bean.user.register({ name: fixture.customerName }, true);
   fixture.userId = customer.id as number;
   await app.bean.passport.signinMock(fixture.customerName as any);
@@ -61,7 +61,111 @@ async function createPaidOrder(suffix: string): Promise<IFixture> {
   } finally {
     await app.bean.passport.signout();
   }
-  return fixture;
+}
+
+async function runInMockCtx<TResult>(
+  customerName: string | undefined,
+  operation: () => Promise<TResult>,
+): Promise<TResult> {
+  return await app.bean.executor.mockCtx(async () => {
+    if (customerName === undefined) {
+      await app.bean.passport.signinMock();
+    } else {
+      await app.bean.passport.signinMock(customerName as any);
+    }
+    try {
+      return await operation();
+    } finally {
+      await app.bean.passport.signout();
+    }
+  });
+}
+
+async function withTimeout<TResult>(promise: Promise<TResult>, message: string): Promise<TResult> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(message)), 5_000);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+async function waitForHolderStage(
+  entered: Promise<void>,
+  holder: Promise<unknown>,
+  label: string,
+): Promise<void> {
+  return await withTimeout(
+    Promise.race([
+      entered,
+      holder.then(
+        () =>
+          Promise.reject(new Error(`${label} completed before reaching its lock-holding stage`)),
+        error => Promise.reject(error),
+      ),
+    ]),
+    `${label} did not reach its lock-holding stage`,
+  );
+}
+
+async function waitForPostgresWaiter(waiterPid: number, holderPid: number): Promise<void> {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    const result = await app.bean.database.current.connection.raw(
+      `
+        select wait_event_type
+          from pg_stat_activity
+         where pid = ?
+           and ? = any(pg_blocking_pids(pid))
+      `,
+      [waiterPid, holderPid],
+    );
+    if (result.rows[0]) {
+      assert.equal(result.rows[0].wait_event_type, 'Lock');
+      return;
+    }
+    await new Promise(resolve => setTimeout(resolve, 10));
+  }
+  assert.fail(`PostgreSQL backend ${waiterPid} was not blocked by backend ${holderPid}`);
+}
+
+async function assertPersistedRefundOutcome(
+  orderId: number,
+  expected: {
+    orderState: string;
+    refundState: string;
+    refundAttemptState: string;
+    orderAuditOperations: readonly string[];
+    refundAuditStates: readonly string[];
+  },
+): Promise<void> {
+  const trade = app.scope('commerce-trade');
+  const payment = app.scope('commerce-payment');
+  const order = await trade.model.order.getById(orderId);
+  const shipments = await trade.model.shipment.select({ where: { orderId } });
+  const requests = await payment.model.refundRequest.select({ where: { orderId } });
+  const attempts = await payment.model.refundAttempt.select({
+    where: { refundRequestId: requests[0]?.id },
+  });
+  const orderAudits = await trade.model.orderAudit.select({ where: { orderId } });
+  const refundAudits = await payment.model.refundAudit.select({ where: { orderId } });
+
+  assert.equal(order?.state, expected.orderState);
+  assert.equal(shipments.length, 0);
+  assert.equal(requests.length, 1);
+  assert.equal(requests[0]?.state, expected.refundState);
+  assert.equal(attempts.length, 1);
+  assert.equal(attempts[0]?.state, expected.refundAttemptState);
+  for (const operation of expected.orderAuditOperations) {
+    assert.equal(orderAudits.filter(item => item.operation === operation).length, 1);
+  }
+  assert.equal(orderAudits.filter(item => item.operation === 'shipped').length, 0);
+  assert.deepEqual(refundAudits.map(item => item.toRefundState).sort(), expected.refundAuditStates);
 }
 
 describe('shipmentRefundRace.test.ts', { concurrency: false, sequential: true }, () => {
@@ -83,31 +187,65 @@ describe('shipmentRefundRace.test.ts', { concurrency: false, sequential: true },
     const fixture: IFixture = {};
     try {
       await app.bean.executor.mockCtx(async () => {
-        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        await createPaidOrder(fixture, randomUUID().slice(0, 12));
       });
-      const requestRefund = app.bean.executor.mockCtx(async () => {
-        await app.bean.passport.signinMock(fixture.customerName as any);
-        try {
-          return await app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+      const requestEntered = Promise.withResolvers<void>();
+      const releaseRequest = Promise.withResolvers<void>();
+      let requestPid: number | undefined;
+      const requestRefund = runInMockCtx(fixture.customerName, async () => {
+        return await app.scope('commerce-trade').service.order.requestRefundForTest(
+          fixture.orderId!,
+          {
             reason: 'race request',
             idempotencyKey: 'shipment-refund-race-request-1',
-          });
-        } finally {
-          await app.bean.passport.signout();
-        }
+          },
+          async stage => {
+            if (stage !== 'afterRefundRequestOrderState') return;
+            const result = await app.bean.database.current.connection.raw(
+              'select pg_backend_pid() as pid',
+            );
+            requestPid = result.rows[0].pid;
+            requestEntered.resolve();
+            await releaseRequest.promise;
+          },
+        );
       });
-      const ship = app.bean.executor.mockCtx(async () => {
-        await app.bean.passport.signinMock();
-        try {
-          return await app.scope('commerce-trade').service.order.ship(fixture.orderId!, {
-            carrier: 'Cabloy Express',
-            trackingNumber: 'CAB-RFD-1',
-          });
-        } finally {
-          await app.bean.passport.signout();
-        }
-      });
-      await Promise.allSettled([requestRefund, ship]);
+      const shipmentReady = Promise.withResolvers<void>();
+      const releaseShipment = Promise.withResolvers<void>();
+      let shipmentPid: number | undefined;
+      let ship: Promise<unknown> | undefined;
+      try {
+        await waitForHolderStage(requestEntered.promise, requestRefund, 'refund request');
+        assert.notEqual(requestPid, undefined);
+        ship = runInMockCtx(undefined, async () => {
+          return await app.scope('commerce-trade').service.order.shipForTest(
+            fixture.orderId!,
+            {
+              carrier: 'Cabloy Express',
+              trackingNumber: 'CAB-RFD-1',
+            },
+            async stage => {
+              if (stage !== 'beforeOrderLock') return;
+              const result = await app.bean.database.current.connection.raw(
+                'select pg_backend_pid() as pid',
+              );
+              shipmentPid = result.rows[0].pid;
+              shipmentReady.resolve();
+              await releaseShipment.promise;
+            },
+          );
+        });
+        await waitForHolderStage(shipmentReady.promise, ship, 'shipment');
+        assert.notEqual(shipmentPid, undefined);
+        releaseShipment.resolve();
+        await app.bean.executor.mockCtx(async () => {
+          await waitForPostgresWaiter(shipmentPid!, requestPid!);
+        });
+      } finally {
+        releaseShipment.resolve();
+        releaseRequest.resolve();
+        await Promise.allSettled([requestRefund, ship].filter(Boolean));
+      }
       await app.bean.executor.mockCtx(async () => {
         const trade = app.scope('commerce-trade');
         const payment = app.scope('commerce-payment');
@@ -140,4 +278,219 @@ describe('shipmentRefundRace.test.ts', { concurrency: false, sequential: true },
       });
     }
   });
+
+  it('rejects shipment when refund approval contends for the locked refund-requested order', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+    const fixture: IFixture = {};
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await createPaidOrder(fixture, randomUUID().slice(0, 12));
+      });
+      await runInMockCtx(fixture.customerName, async () => {
+        await app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+          reason: 'race approval request',
+          idempotencyKey: 'shipment-refund-race-approval-request-1',
+        });
+      });
+      const entered = Promise.withResolvers<void>();
+      const release = Promise.withResolvers<void>();
+      let holderPid: number | undefined;
+      const approveRefund = runInMockCtx(undefined, async () => {
+        return await app.scope('commerce-trade').service.order.reviewRefundForTest(
+          fixture.orderId!,
+          {
+            reason: 'race approval',
+            idempotencyKey: 'shipment-refund-race-approval-1',
+          },
+          'approved',
+          async stage => {
+            if (stage !== 'afterRefundReviewOrderState') return;
+            const result = await app.bean.database.current.connection.raw(
+              'select pg_backend_pid() as pid',
+            );
+            holderPid = result.rows[0].pid;
+            entered.resolve();
+            await release.promise;
+          },
+        );
+      });
+      const shipmentReady = Promise.withResolvers<void>();
+      const releaseShipment = Promise.withResolvers<void>();
+      let shipmentPid: number | undefined;
+      let ship: Promise<unknown> | undefined;
+      let results: PromiseSettledResult<unknown>[] | undefined;
+      try {
+        await waitForHolderStage(entered.promise, approveRefund, 'refund approval');
+        assert.notEqual(holderPid, undefined);
+        ship = runInMockCtx(undefined, async () => {
+          return await app.scope('commerce-trade').service.order.shipForTest(
+            fixture.orderId!,
+            {
+              carrier: 'Cabloy Express',
+              trackingNumber: 'CAB-RFD-APPROVAL-1',
+            },
+            async stage => {
+              if (stage !== 'beforeOrderLock') return;
+              const result = await app.bean.database.current.connection.raw(
+                'select pg_backend_pid() as pid',
+              );
+              shipmentPid = result.rows[0].pid;
+              shipmentReady.resolve();
+              await releaseShipment.promise;
+            },
+          );
+        });
+        await waitForHolderStage(shipmentReady.promise, ship, 'shipment');
+        assert.notEqual(shipmentPid, undefined);
+        releaseShipment.resolve();
+        await app.bean.executor.mockCtx(async () => {
+          await waitForPostgresWaiter(shipmentPid!, holderPid!);
+        });
+      } finally {
+        releaseShipment.resolve();
+        release.resolve();
+        results = await Promise.allSettled([approveRefund, ship].filter(Boolean));
+      }
+      const [approvalResult, shipmentResult] = results!;
+      const message = JSON.stringify(results);
+      assert.equal(approvalResult.status, 'fulfilled', message);
+      assert.equal(shipmentResult.status, 'rejected', message);
+      if (approvalResult.status !== 'fulfilled' || shipmentResult.status !== 'rejected') return;
+      assert.deepEqual(
+        [
+          approvalResult.value.orderState,
+          approvalResult.value.refundState,
+          approvalResult.value.refundAttemptState,
+        ],
+        ['refund_approved', 'approved', 'created'],
+      );
+      assert.equal(shipmentResult.reason?.code, 409);
+      await app.bean.executor.mockCtx(async () => {
+        await assertPersistedRefundOutcome(fixture.orderId!, {
+          orderState: 'refund_approved',
+          refundState: 'approved',
+          refundAttemptState: 'created',
+          orderAuditOperations: ['refund_requested', 'refund_approved'],
+          refundAuditStates: ['approved', 'requested'],
+        });
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await cleanup(fixture);
+      });
+    }
+  });
+
+  it('rejects shipment when successful refund execution contends for the locked approved order', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+    const fixture: IFixture = {};
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await createPaidOrder(fixture, randomUUID().slice(0, 12));
+      });
+      await runInMockCtx(fixture.customerName, async () => {
+        await app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+          reason: 'race execution request',
+          idempotencyKey: 'shipment-refund-race-execution-request-1',
+        });
+      });
+      await runInMockCtx(undefined, async () => {
+        await app.scope('commerce-trade').service.order.approveRefund(fixture.orderId!, {
+          reason: 'race execution approval',
+          idempotencyKey: 'shipment-refund-race-execution-approval-1',
+        });
+      });
+      const entered = Promise.withResolvers<void>();
+      const release = Promise.withResolvers<void>();
+      let holderPid: number | undefined;
+      const executeRefund = runInMockCtx(undefined, async () => {
+        return await app.scope('commerce-trade').service.order.applyRefundOutcomeForTest(
+          fixture.orderId!,
+          {
+            outcome: 'succeeded',
+            idempotencyKey: 'shipment-refund-race-execution-outcome-1',
+          },
+          async stage => {
+            if (stage !== 'afterRefundOutcomeOrderState') return;
+            const result = await app.bean.database.current.connection.raw(
+              'select pg_backend_pid() as pid',
+            );
+            holderPid = result.rows[0].pid;
+            entered.resolve();
+            await release.promise;
+          },
+        );
+      });
+      const shipmentReady = Promise.withResolvers<void>();
+      const releaseShipment = Promise.withResolvers<void>();
+      let shipmentPid: number | undefined;
+      let ship: Promise<unknown> | undefined;
+      let results: PromiseSettledResult<unknown>[] | undefined;
+      try {
+        await waitForHolderStage(entered.promise, executeRefund, 'refund execution');
+        assert.notEqual(holderPid, undefined);
+        ship = runInMockCtx(undefined, async () => {
+          return await app.scope('commerce-trade').service.order.shipForTest(
+            fixture.orderId!,
+            {
+              carrier: 'Cabloy Express',
+              trackingNumber: 'CAB-RFD-EXECUTION-1',
+            },
+            async stage => {
+              if (stage !== 'beforeOrderLock') return;
+              const result = await app.bean.database.current.connection.raw(
+                'select pg_backend_pid() as pid',
+              );
+              shipmentPid = result.rows[0].pid;
+              shipmentReady.resolve();
+              await releaseShipment.promise;
+            },
+          );
+        });
+        await waitForHolderStage(shipmentReady.promise, ship, 'shipment');
+        assert.notEqual(shipmentPid, undefined);
+        releaseShipment.resolve();
+        await app.bean.executor.mockCtx(async () => {
+          await waitForPostgresWaiter(shipmentPid!, holderPid!);
+        });
+      } finally {
+        releaseShipment.resolve();
+        release.resolve();
+        results = await Promise.allSettled([executeRefund, ship].filter(Boolean));
+      }
+      const [refundResult, shipmentResult] = results!;
+      const message = JSON.stringify(results);
+      assert.equal(refundResult.status, 'fulfilled', message);
+      assert.equal(shipmentResult.status, 'rejected', message);
+      if (refundResult.status !== 'fulfilled' || shipmentResult.status !== 'rejected') return;
+      assert.deepEqual(
+        [
+          refundResult.value.orderState,
+          refundResult.value.refundState,
+          refundResult.value.refundAttemptState,
+        ],
+        ['refunded', 'refunded', 'succeeded'],
+      );
+      assert.equal(shipmentResult.reason?.code, 409);
+      await app.bean.executor.mockCtx(async () => {
+        await assertPersistedRefundOutcome(fixture.orderId!, {
+          orderState: 'refunded',
+          refundState: 'refunded',
+          refundAttemptState: 'succeeded',
+          orderAuditOperations: ['refund_requested', 'refund_approved', 'refunded'],
+          refundAuditStates: ['approved', 'refunded', 'requested'],
+        });
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await cleanup(fixture);
+      });
+    }
+  });
 });

package/vona/src/suite/a-training/modules/training-record/src/dto/recordSelectResItem.tsx

@@ -16,7 +16,30 @@ export interface IDtoOptionsRecordSelectResItem extends IDecoratorDtoOptions {}
   blocks: [
     ZovaRender.block('basic-page:blockPage', {
       blocks: [
-        ZovaRender.block('basic-page:blockFilter'),
+        ZovaRender.block('basic-page:blockFilter', {
+          formFieldLayout: { inline: true },
+          blocks: [
+            ZovaRender.block('basic-form:blockFormLayout', {
+              formLayout: {
+                children: [
+                  {
+                    type: 'section',
+                    layout: 'flow',
+                    children: [
+                      { type: 'field', name: 'name' },
+                      { type: 'field', name: 'studentId' },
+                      { type: 'field', name: 'createdAt' },
+                      {
+                        type: 'block',
+                        block: ZovaRender.block('basic-page:blockFilterActions'),
+                      },
+                    ],
+                  },
+                ],
+              },
+            }),
+          ],
+        }),
         ZovaRender.block('basic-page:blockToolbarBulk', {
           actions: [ZovaRender.tableActionBulk('basic-table:actionCreate')],
         }),

package/vona/src/suite/a-training/modules/training-student/src/dto/studentSelectResItem.tsx

@@ -28,12 +28,15 @@ export interface IDtoOptionsStudentSelectResItem extends IDecoratorDtoOptions {}
                       { type: 'field', name: 'name' },
                       { type: 'field', name: 'level' },
                       { type: 'field', name: 'createdAt' },
+                      {
+                        type: 'block',
+                        block: ZovaRender.block('basic-page:blockFilterActions'),
+                      },
                     ],
                   },
                 ],
               },
             }),
-            ZovaRender.block('basic-page:blockFilterActions'),
           ],
         }),
         ZovaRender.block('basic-page:blockToolbarBulk', {

package/vona/src/suite/a-training/modules/training-student/test/student.test.ts

@@ -57,16 +57,23 @@ describe('student.test.ts', () => {
       assert.equal(filterBlock?.options?.formFieldLayout?.inline, true);
       assert.deepEqual(
         filterBlock?.options?.blocks?.map(item => item.render),
-        ['basic-form:blockFormLayout', 'basic-page:blockFilterActions'],
+        ['basic-form:blockFormLayout'],
       );
       const formLayout = filterBlock?.options?.blocks?.[0]?.options?.formLayout;
+      const filterLayoutChildren = formLayout?.children[0]?.children;
       assert.equal(formLayout?.children[0]?.layout, 'flow');
       assert.equal(formLayout?.children[0]?.columns, undefined);
+      assert.equal(filterLayoutChildren?.length, 4);
       assert.deepEqual(
-        formLayout?.children[0]?.children.map(item => item.name),
+        filterLayoutChildren?.map(item => item.type),
+        ['field', 'field', 'field', 'block'],
+      );
+      assert.deepEqual(
+        filterLayoutChildren?.slice(0, 3).map(item => item.name),
         ['name', 'level', 'createdAt'],
       );
-      assert.equal(formLayout?.children[0]?.children[2]?.span, undefined);
+      assert.equal(filterLayoutChildren?.[2]?.span, undefined);
+      assert.equal(filterLayoutChildren?.[3]?.block?.render, 'basic-page:blockFilterActions');
     });
   });
 

package/zova/packages-zova/zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova",
-  "version": "5.1.141",
+  "version": "5.1.142",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A vue3 framework with ioc",
   "keywords": [
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "zova-core": "^5.1.79",
-    "zova-suite-a-zova": "^5.1.140"
+    "zova-suite-a-zova": "^5.1.141"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/zova/pnpm-lock.yaml

@@ -849,7 +849,7 @@ importers:
         specifier: ^5.1.79
         version: link:../zova-core
       zova-suite-a-zova:
-        specifier: ^5.1.140
+        specifier: ^5.1.141
         version: link:../../src/suite-vendor/a-zova
     devDependencies:
       clean-package:
@@ -986,7 +986,7 @@ importers:
         specifier: ^5.1.24
         version: link:modules/a-fetch
       zova-module-a-form:
-        specifier: ^5.1.45
+        specifier: ^5.1.46
         version: link:modules/a-form
       zova-module-a-icon:
         specifier: ^5.1.26
@@ -1004,7 +1004,7 @@ importers:
         specifier: ^5.1.33
         version: link:modules/a-model
       zova-module-a-openapi:
-        specifier: ^5.1.46
+        specifier: ^5.1.47
         version: link:modules/a-openapi
       zova-module-a-router:
         specifier: ^5.1.31

package/zova/src/suite/cabloy-basic/modules/basic-form/src/component/blockFormLayout/controller.tsx

@@ -2,7 +2,9 @@ import type { IComponentOptions } from 'zova';
 import type {
   IJsxRenderContextForm,
   IResolvedFormLayout,
+  IResolvedFormLayoutBlock,
   IResolvedFormLayoutField,
+  IResolvedFormLayoutLeaf,
   IResolvedFormLayoutGroup,
   IResolvedFormLayoutNode,
   IResolvedFormLayoutSection,
@@ -78,6 +80,8 @@ export class ControllerBlockFormLayout extends BeanControllerBase {
     switch (node.type) {
       case 'field':
         return this._renderField(node);
+      case 'block':
+        return this._renderBlock(node);
       case 'group':
         return this._renderGroup(node);
       case 'section':
@@ -87,11 +91,28 @@ export class ControllerBlockFormLayout extends BeanControllerBase {
     }
   }
 
-  private _renderField(node: IResolvedFormLayoutField, sectionLayout?: 'grid' | 'flow') {
-    const { $$form } = this.$$renderContext;
+  private _renderLeaf(node: IResolvedFormLayoutLeaf, sectionLayout?: 'grid' | 'flow') {
     const className =
       sectionLayout === 'flow' ? 'min-w-0 max-w-full' : this._gridClasses('col-span', node.span);
-    return <div class={className}>{$$form.renderField(node.name)}</div>;
+    return <div class={className}>{this._renderLeafContent(node)}</div>;
+  }
+
+  private _renderLeafContent(node: IResolvedFormLayoutLeaf) {
+    if (node.type === 'field') return this.$$renderContext.$$form.renderField(node.name);
+    return this._renderBlockContent(node);
+  }
+
+  private _renderField(node: IResolvedFormLayoutField) {
+    return this._renderLeaf(node);
+  }
+
+  private _renderBlock(node: IResolvedFormLayoutBlock) {
+    return this._renderLeaf(node);
+  }
+
+  private _renderBlockContent(node: IResolvedFormLayoutBlock) {
+    const { $celScope, $jsx } = this.$$renderContext;
+    return $jsx.render(node.block.render!, node.block.options, $celScope, this.$$renderContext);
   }
 
   private _renderGroup(node: IResolvedFormLayoutGroup) {
@@ -114,7 +135,7 @@ export class ControllerBlockFormLayout extends BeanControllerBase {
       <section>
         {!!node.title && <h3 class="mb-1 text-lg font-semibold">{node.title}</h3>}
         {!!node.description && <p class="mb-4 text-sm text-base-content/70">{node.description}</p>}
-        <div class={className}>{node.children.map(child => this._renderField(child, layout))}</div>
+        <div class={className}>{node.children.map(child => this._renderLeaf(child, layout))}</div>
       </section>
     );
   }

package/zova/src/suite-vendor/a-zova/modules/a-form/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-form",
-  "version": "5.1.45",
+  "version": "5.1.46",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-form/src/component/form/controller.tsx

@@ -411,6 +411,7 @@ export class ControllerForm<
     if (node.type === 'field') {
       return this.formState.fieldMeta[node.name]?.errors?.length ? 1 : 0;
     }
+    if (node.type === 'block') return 0;
     return node.children.reduce((count, child) => {
       return count + this._getFormLayoutErrorFieldCount(child);
     }, 0);