cabloy 5.1.125 → 5.1.127

package/e2e/specs/a-commerce/commerce.spec.ts

@@ -535,7 +535,9 @@ test(
       await orderCard.getByRole('button', { name: 'View', exact: true }).click();
       await expect(page).toHaveURL(new RegExp(`/commerce/order/${checkout.orderId}(?:/|$)`));
       await historyDetailResponse;
-      await expect(page.getByRole('heading', { name: `Order #${checkout.orderId}` })).toBeVisible();
+      await expect(
+        page.getByRole('heading', { name: `Order #${checkout.orderId}`, level: 1 }),
+      ).toBeVisible();
       await expect(page.getByText('1 × $45.99 = $45.99')).toBeVisible();
       await expect(page.getByRole('alert')).toHaveCount(0);
       expect(pageErrors).toEqual([]);
@@ -705,11 +707,39 @@ test(
         const executeResponse = waitForApiResponse(
           adminPage,
           'POST',
-          `/api/commerce/trade/order/${checkout.orderId}/refundOutcome`,
+          `/api/commerce/trade/order/${checkout.orderId}/executeRefund`,
         );
         await orderRow.getByRole('button', { name: 'Execute refund', exact: true }).click();
-        expect((await executeResponse).ok()).toBeTruthy();
-        await expect(orderRow).toContainText('refunded');
+        const executeResponseValue = await executeResponse;
+        expect(executeResponseValue.ok()).toBeTruthy();
+        const executeResult = (await executeResponseValue.json()).data;
+        const authorization = executeResponseValue.request().headers()['authorization'];
+        expect(authorization).toMatch(/^Bearer /);
+        const authHeaders = { Authorization: authorization };
+        expectTableIdentity(executeResult.refundAttemptId);
+        expectTableIdentity(executeResult.refundOperationId);
+        expect([
+          executeResult.orderState,
+          executeResult.refundState,
+          executeResult.refundAttemptState,
+        ]).toEqual(['refund_approved', 'approved', 'created']);
+        const completeRefundResponse = await adminPage.request.post(
+          `/api/pay/mock/payment-session/refund-operation/${executeResult.refundOperationId}/complete`,
+          { headers: authHeaders, data: { outcome: 'succeeded' } },
+        );
+        expect(completeRefundResponse.ok()).toBeTruthy();
+        await expect
+          .poll(
+            async () => {
+              await adminPage.reload({ waitUntil: 'load' });
+              const currentOrderRow = await getAdminOrderRow(adminPage, checkout.orderId);
+              return (await currentOrderRow.textContent()) ?? '';
+            },
+            { timeout: 40_000 },
+          )
+          .toContain('refunded');
+        const refundedOrderRow = await getAdminOrderRow(adminPage, checkout.orderId);
+        await expect(refundedOrderRow).toContainText('refunded');
         expect(adminPageErrors).toEqual([]);
       } finally {
         await adminContext.close().catch(() => {});
@@ -796,6 +826,196 @@ test(
   },
 );
 
+test(
+  'ATP-SPC-01: Coupon Template renders semantic Admin field controls',
+  { tag: ['@admin', '@flow', '@fia'] },
+  async ({ browser }) => {
+    test.setTimeout(60_000);
+    const adminContext = await browser.newContext();
+    const adminPage = await adminContext.newPage();
+    const adminPageErrors = collectPageErrors(adminPage);
+    try {
+      await adminPage.setViewportSize({ width: 1440, height: 900 });
+      await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+      await adminPage.goto(
+        '/commerce-admin/rest/resource/commerce-promotion%3AcouponTemplate/create',
+        {
+          waitUntil: 'load',
+        },
+      );
+      await expect(adminPage).toHaveURL(
+        /\/commerce-admin\/rest\/resource\/commerce-promotion(?:%3A|:|%253A)couponTemplate\/create(?:[/?#]|$)/,
+      );
+
+      for (const groupName of [
+        'Basic Information',
+        'Discount Policy',
+        'Validity Window',
+        'Usage Limits',
+      ]) {
+        await expect(adminPage.getByRole('group', { name: groupName })).toBeVisible();
+      }
+
+      const state = adminPage
+        .getByRole('group', { name: 'Template State *' })
+        .getByRole('combobox');
+      await expect(state).toBeVisible();
+      await state.selectOption({ label: 'Active' });
+      await expect(state).toHaveValue('active');
+
+      const discountInput = adminPage
+        .getByRole('group', { name: 'Fixed Discount *' })
+        .getByRole('textbox');
+      const minSpendInput = adminPage
+        .getByRole('group', { name: 'Minimum Spend *' })
+        .getByRole('textbox');
+      await discountInput.fill('12.34');
+      await minSpendInput.fill('45.67');
+      await expect(discountInput).toHaveValue('12.34');
+      await expect(minSpendInput).toHaveValue('45.67');
+      await expect(
+        adminPage.getByRole('group', { name: 'Valid From *' }).locator('input[type="date"]'),
+      ).toBeVisible();
+      await expect(
+        adminPage.getByRole('group', { name: 'Valid Until *' }).locator('input[type="date"]'),
+      ).toBeVisible();
+
+      await adminPage
+        .getByRole('group', { name: 'Name *' })
+        .getByRole('textbox')
+        .fill('E2E Coupon Template');
+      await adminPage.getByRole('group', { name: 'Currency *' }).getByRole('textbox').fill('USD');
+      await adminPage
+        .getByRole('group', { name: 'Valid From *' })
+        .getByRole('textbox')
+        .fill('2026-08-04');
+      await adminPage
+        .getByRole('group', { name: 'Valid Until *' })
+        .getByRole('textbox')
+        .fill('2026-12-31');
+      await adminPage
+        .getByRole('group', { name: 'Total Issue Limit' })
+        .getByRole('textbox')
+        .fill('10');
+      await adminPage
+        .getByRole('group', { name: 'Total Usage Limit' })
+        .getByRole('textbox')
+        .fill('10');
+      await adminPage
+        .getByRole('group', { name: 'Per-customer Issue Limit' })
+        .getByRole('textbox')
+        .fill('1');
+
+      await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toBeVisible();
+      await expect(adminPage.getByRole('button', { name: 'Back', exact: true })).toBeVisible();
+      expect(adminPageErrors).toEqual([]);
+    } finally {
+      await adminContext.close().catch(() => {});
+    }
+  },
+);
+
+test(
+  'ATP-SPC-02: Category renders semantic Admin relation and publication controls',
+  { tag: ['@admin', '@flow', '@category'] },
+  async ({ browser }, testInfo) => {
+    test.setTimeout(60_000);
+    const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+    const parentName = `E2E Category Parent ${suffix}`;
+    const childName = `E2E Category Child ${suffix}`;
+    const adminContext = await browser.newContext();
+    const adminPage = await adminContext.newPage();
+    const adminPageErrors = collectPageErrors(adminPage);
+    const categoryCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory/create';
+    const categoryListPath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory';
+    const categoryActionPath = '/api/commerce/catalog/category';
+    let parentId: number | string | undefined;
+    let childId: number | string | undefined;
+    let headers: { Authorization: string } | undefined;
+    try {
+      await adminPage.setViewportSize({ width: 1440, height: 900 });
+      await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+      const accessToken = (await adminContext.cookies()).find(
+        cookie => cookie.name === 'token',
+      )?.value;
+      expect(accessToken).toBeTruthy();
+      headers = { Authorization: `Bearer ${accessToken}` };
+
+      const parentCreateResponse = await adminPage.request.post(categoryActionPath, {
+        data: { name: parentName, published: false },
+        headers,
+      });
+      expect(parentCreateResponse.ok()).toBeTruthy();
+      parentId = (await parentCreateResponse.json()).data;
+      expectTableIdentity(parentId);
+
+      await adminPage.goto(categoryCreatePath, { waitUntil: 'load' });
+      const parentPublication = adminPage
+        .getByRole('group', { name: 'Published' })
+        .getByRole('combobox');
+      await expect(parentPublication).toBeVisible();
+      await expect(parentPublication.locator('option')).toHaveText([
+        '',
+        'Unpublished',
+        'Published',
+      ]);
+      await parentPublication.selectOption({ label: 'Unpublished' });
+      await expect(parentPublication).toHaveValue('false');
+
+      const parentPicker = adminPage
+        .getByRole('group', { name: 'Parent category' })
+        .getByRole('combobox');
+      await expect(parentPicker).toBeVisible();
+      await parentPicker.selectOption({ label: parentName });
+      const parentValue = await parentPicker.inputValue();
+      expect(parentValue).toBe(String(parentId));
+      const childPublication = adminPage
+        .getByRole('group', { name: 'Published' })
+        .getByRole('combobox');
+      await childPublication.selectOption({ label: 'Published' });
+      await expect(childPublication).toHaveValue('true');
+
+      const childCreateResponse = await adminPage.request.post(categoryActionPath, {
+        data: { name: childName, parentId: parentValue, published: true },
+        headers,
+      });
+      expect(childCreateResponse.ok()).toBeTruthy();
+      childId = (await childCreateResponse.json()).data;
+      expectTableIdentity(childId);
+
+      await adminPage.goto(categoryListPath, { waitUntil: 'load' });
+      const childRow = adminPage.getByRole('row', { name: new RegExp(childName) });
+      await expect(childRow).toBeVisible();
+      await expect(childRow.getByText(parentName, { exact: true })).toBeVisible();
+      await expect(childRow.getByText('Published', { exact: true })).toBeVisible();
+
+      await adminPage.goto(`${categoryListPath}/${childId}`, { waitUntil: 'load' });
+      await expect(
+        adminPage.getByRole('group', { name: 'Parent category' }).getByRole('textbox'),
+      ).toHaveValue(parentName);
+      await expect(
+        adminPage.getByRole('group', { name: 'Published' }).getByRole('textbox'),
+      ).toHaveValue('Published');
+      await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+      expect(adminPageErrors).toEqual([]);
+    } finally {
+      if (childId && headers) {
+        const response = await adminPage.request.delete(`${categoryActionPath}/${childId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      if (parentId && headers) {
+        const response = await adminPage.request.delete(`${categoryActionPath}/${parentId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      await adminContext.close().catch(() => {});
+    }
+  },
+);
+
 test(
   'Commerce Cart: anonymous browser is redirected to login',
   { tag: ['@web', '@cart'] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.125",
+  "version": "5.1.127",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [
@@ -23,6 +23,7 @@
   "scripts": {
     "init": "node scripts/init.ts",
     "init:test-data": "node scripts/initTestData.ts",
+    "test:scripts": "node --test scripts/initAppName.test.ts",
     "upgrade": "node scripts/upgrade.ts",
     "upgrade:dry-run": "node scripts/upgrade.ts --dry-run",
     "vona": "node ./vona/packages-cli/cli/src/bin/vona.ts --projectPath=vona",

package/scripts/init.ts

@@ -9,10 +9,11 @@ import {
   rmSync,
   writeFileSync,
 } from 'node:fs';
-import { basename } from 'node:path';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { updateBaseAppName } from './initAppName.ts';
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT_DIR = resolve(__dirname, '..');
 const VONA_DIR = resolve(ROOT_DIR, 'vona');
@@ -141,19 +142,13 @@ function seedVonaZovaRestWorkspaceDependencies(pkgPath: string): void {
   console.log('[init] Seeded Vona .zova-rest dependencies');
 }
 
-// --- Step 0: Set APP_NAME in .env files ---
+// --- Step 0: Set APP_NAME in base .env files ---
 
 function setAppName(): void {
-  const projectName = basename(ROOT_DIR);
-  const envFiles = [resolve(ROOT_DIR, 'vona/env/.env'), resolve(ROOT_DIR, 'zova/env/.env')];
-  for (const filePath of envFiles) {
-    if (!existsSync(filePath)) continue;
-    let content = readFileSync(filePath, 'utf-8');
-    content = content.replace(/^APP_NAME.*/m, `APP_NAME = ${projectName}`);
-    writeFileSync(filePath, content);
-    // eslint-disable-next-line
-    console.log(`[init] Set APP_NAME = ${projectName} in ${filePath}`);
-  }
+  updateBaseAppName(ROOT_DIR);
+  // if (updateBaseAppName(ROOT_DIR)) return;
+  // eslint-disable-next-line
+  // console.log('[init] Linked Git worktree detected; preserving base APP_NAME defaults');
 }
 
 // --- Step A: Generate vona/env/.env.prod.local ---

package/scripts/initAppName.test.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, resolve } from 'node:path';
+import test from 'node:test';
+
+import { isLinkedGitWorktree, updateBaseAppName } from './initAppName.ts';
+
+function git(cwd: string, args: string[]): void {
+  execFileSync('git', args, { cwd, stdio: 'ignore' });
+}
+
+function writeBaseEnvFiles(rootDir: string, appName: string): void {
+  for (const relativePath of ['vona/env/.env', 'zova/env/.env']) {
+    const filePath = resolve(rootDir, relativePath);
+    mkdirSync(resolve(filePath, '..'), { recursive: true });
+    writeFileSync(filePath, `APP_NAME = ${appName}\nOTHER_VALUE = preserved\n`);
+  }
+}
+
+function readBaseEnvFiles(rootDir: string): string[] {
+  return ['vona/env/.env', 'zova/env/.env'].map(relativePath =>
+    readFileSync(resolve(rootDir, relativePath), 'utf-8'),
+  );
+}
+
+test('classifies project roots before updating base APP_NAME files', { concurrency: false }, () => {
+  const tempDir = mkdtempSync(resolve(tmpdir(), 'cabloy-init-app-name-'));
+  const primaryDir = resolve(tempDir, 'primary');
+  const linkedDir = resolve(tempDir, 'linked');
+  try {
+    mkdirSync(primaryDir);
+    git(primaryDir, ['init']);
+    git(primaryDir, ['config', 'user.email', 'test@example.com']);
+    git(primaryDir, ['config', 'user.name', 'Cabloy Test']);
+    writeBaseEnvFiles(primaryDir, 'original');
+    git(primaryDir, ['add', '.']);
+    git(primaryDir, ['commit', '-m', 'initial fixture']);
+
+    assert.equal(isLinkedGitWorktree(primaryDir), false);
+    assert.equal(updateBaseAppName(primaryDir), true);
+    for (const content of readBaseEnvFiles(primaryDir)) {
+      assert.equal(content, `APP_NAME = ${basename(primaryDir)}\nOTHER_VALUE = preserved\n`);
+    }
+
+    git(primaryDir, ['checkout', '--', '.']);
+    git(primaryDir, ['worktree', 'add', '--detach', linkedDir, 'HEAD']);
+    const linkedBefore = readBaseEnvFiles(linkedDir);
+    assert.equal(isLinkedGitWorktree(linkedDir), true);
+    assert.equal(updateBaseAppName(linkedDir), false);
+    assert.deepEqual(readBaseEnvFiles(linkedDir), linkedBefore);
+
+    const nestedProjectDir = resolve(linkedDir, 'created-project');
+    writeBaseEnvFiles(nestedProjectDir, 'original');
+    assert.equal(isLinkedGitWorktree(nestedProjectDir), false);
+    assert.equal(updateBaseAppName(nestedProjectDir), true);
+    for (const content of readBaseEnvFiles(nestedProjectDir)) {
+      assert.equal(content, `APP_NAME = ${basename(nestedProjectDir)}\nOTHER_VALUE = preserved\n`);
+    }
+
+    const nonGitProjectDir = resolve(tempDir, 'non-git-project');
+    writeBaseEnvFiles(nonGitProjectDir, 'original');
+    assert.equal(isLinkedGitWorktree(nonGitProjectDir), false);
+    assert.equal(updateBaseAppName(nonGitProjectDir), true);
+    for (const content of readBaseEnvFiles(nonGitProjectDir)) {
+      assert.equal(content, `APP_NAME = ${basename(nonGitProjectDir)}\nOTHER_VALUE = preserved\n`);
+    }
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});

package/scripts/initAppName.ts

@@ -0,0 +1,50 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+
+function gitOutput(rootDir: string, args: string[]): string {
+  return execFileSync('git', args, {
+    cwd: rootDir,
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).trim();
+}
+
+export function isLinkedGitWorktree(rootDir: string): boolean {
+  const projectRoot = realpathSync(resolve(rootDir));
+  try {
+    const gitRoot = realpathSync(
+      resolve(gitOutput(projectRoot, ['rev-parse', '--path-format=absolute', '--show-toplevel'])),
+    );
+    if (gitRoot !== projectRoot) return false;
+
+    const gitDir = realpathSync(
+      resolve(gitOutput(projectRoot, ['rev-parse', '--path-format=absolute', '--git-dir'])),
+    );
+    const gitCommonDir = realpathSync(
+      resolve(gitOutput(projectRoot, ['rev-parse', '--path-format=absolute', '--git-common-dir'])),
+    );
+    return gitDir !== gitCommonDir;
+  } catch {
+    return false;
+  }
+}
+
+export function updateBaseAppName(rootDir: string): boolean {
+  if (isLinkedGitWorktree(rootDir)) return false;
+
+  const projectRoot = resolve(rootDir);
+  const projectName = basename(projectRoot);
+  const envFiles = [resolve(projectRoot, 'vona/env/.env'), resolve(projectRoot, 'zova/env/.env')];
+  for (const filePath of envFiles) {
+    if (!existsSync(filePath)) continue;
+    const content = readFileSync(filePath, 'utf-8').replace(
+      /^APP_NAME.*/m,
+      `APP_NAME = ${projectName}`,
+    );
+    writeFileSync(filePath, content);
+    // eslint-disable-next-line
+    console.log(`[init] Set APP_NAME = ${projectName} in ${filePath}`);
+  }
+  return true;
+}

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.136",
+  "version": "1.1.137",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.134",
+  "version": "1.1.135",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.82",
+  "version": "5.1.84",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.35",
+  "version": "5.1.36",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [

package/vona/packages-vona/vona-core/src/lib/bean/resource/error/errorClass.ts

@@ -21,7 +21,7 @@ export class ErrorClass extends BeanSimple {
   fail(module, code, ...args) {
     const body = this.parseFail(module, code, ...args);
 
-    this.ctx.response.status = __calcStatus(body.code);
+    this.ctx.response.status = body.status;
     this.ctx.response.type = 'application/json';
     this.ctx.response.body = { code: body.code, message: body.message }; // body maybe Error
   }
@@ -32,7 +32,7 @@ export class ErrorClass extends BeanSimple {
     const err = new Error();
     err.code = body.code;
     err.message = body.message;
-    err.status = __calcStatus(body.code);
+    err.status = body.status;
     throw err;
   }
 
@@ -58,9 +58,16 @@ export class ErrorClass extends BeanSimple {
 
     // convert from enum
     let text;
+    let status;
     if (ebError && code && typeof code === 'string') {
       text = code;
-      code = ebError[code];
+      const declaration = ebError[code];
+      if (__isErrorDescriptor(declaration)) {
+        code = declaration.code;
+        status = declaration.status;
+      } else {
+        code = declaration;
+      }
     }
 
     if (code === undefined || code === null || code === '') {
@@ -75,10 +82,20 @@ export class ErrorClass extends BeanSimple {
     }
 
     code = __combineErrorCode(module, code);
-    return { code, message };
+    status ??= __calcStatus(code);
+    return { code, status, message };
   }
 }
 
+function __isErrorDescriptor(value) {
+  return (
+    value &&
+    typeof value === 'object' &&
+    typeof value.code === 'number' &&
+    typeof value.status === 'number'
+  );
+}
+
 function __combineErrorCode(module, code) {
   if (typeof code !== 'number' || code <= 1000) return code;
   return module ? `${module}:${code}` : code;

package/vona/packages-vona/vona-core/src/lib/bean/resource/error/errorObject.ts

@@ -1,4 +1,5 @@
 export interface IErrorObject {
   code: number | string;
+  status: number;
   message: string;
 }

package/vona/packages-vona/vona-core/src/lib/bean/type.ts

@@ -29,12 +29,14 @@ export type TypeBeanScopeLocaleKeys = keyof IBeanScopeLocale;
 export interface IBeanScopeErrors {}
 export type TypeBeanScopeErrorsKeys = keyof IBeanScopeErrors;
 
+type TypeErrorDeclarationCode<T> = T extends { code: infer Code } ? Code : T;
+
 export type TypeScopesErrorsHelper<
   ModuleName extends keyof IBeanScopeErrors,
   Errors extends IBeanScopeErrors[ModuleName],
 > = {
   // @ts-ignore: ignore
-  [K in keyof Errors as `${ModuleName}:${Errors[K]}`]: K;
+  [K in keyof Errors as `${ModuleName}:${TypeErrorDeclarationCode<Errors[K]>}`]: K;
 };
 export type TypeScopesErrorCodes = TypeRecordValues<{
   [ModuleName in keyof IBeanScopeErrors]: keyof TypeScopesErrorsHelper<

package/vona/packages-vona/vona-core/src/types/interface/module.ts

@@ -4,7 +4,12 @@ import type { IModuleMain, IMonkeyModule, IMonkeySystem } from './monkey.ts';
 
 export type TypeModuleResourceLocales = Record<string, object>;
 export type TypeModuleResourceLocaleModules = Record<string, TypeModuleResourceLocales>;
-export type TypeModuleResourceErrors = Record<string, number>;
+export interface IModuleResourceErrorDescriptor {
+  code: number;
+  status: number;
+}
+export type TypeModuleResourceError = number | IModuleResourceErrorDescriptor;
+export type TypeModuleResourceErrors = Record<string, TypeModuleResourceError>;
 export type TypeModuleResourceErrorModules = Record<string, TypeModuleResourceErrors>;
 export type TypeModuleResourceConfig = (app: VonaApplication) => object | Promise<object>;
 

package/vona/packages-vona/vona-mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-mock",
-  "version": "6.1.35",
+  "version": "6.1.36",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona mock",
   "keywords": [