create-forgeon 0.3.15 → 0.3.17

package/src/modules/i18n.mjs

@@ -13,6 +13,7 @@ import {
   ensureValidatorSchema,
   upsertEnvLines,
 } from './shared/patch-utils.mjs';
+import { ensureWebProbeDefinition, readManagedWebProbeDefinitions } from './shared/probes.mjs';
 
 function copyFromBase(packageRoot, targetRoot, relativePath) {
   const source = path.join(packageRoot, 'templates', 'base', relativePath);
@@ -39,10 +40,6 @@ function patchApiDockerfile(targetRoot) {
   }
 
   let content = fs.readFileSync(dockerfilePath, 'utf8').replace(/\r\n/g, '\n');
-  content = content.replace(
-    /^COPY package\.json pnpm-workspace\.yaml tsconfig\.base\.json \.\/$/m,
-    'COPY package.json pnpm-workspace.yaml tsconfig.base.json tsconfig.base.node.json tsconfig.base.esm.json ./',
-  );
 
   content = ensureLineAfter(
     content,
@@ -95,22 +92,6 @@ function patchProxyDockerfile(filePath) {
   }
 
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
-
-  content = ensureLineAfter(
-    content,
-    'COPY package.json pnpm-workspace.yaml ./',
-    'COPY tsconfig.base.json ./',
-  );
-  content = ensureLineAfter(
-    content,
-    'COPY tsconfig.base.json ./',
-    'COPY tsconfig.base.node.json ./',
-  );
-  content = ensureLineAfter(
-    content,
-    'COPY tsconfig.base.node.json ./',
-    'COPY tsconfig.base.esm.json ./',
-  );
   content = ensureLineAfter(
     content,
     'COPY apps/web/package.json apps/web/package.json',
@@ -449,118 +430,32 @@ Module env:
   fs.writeFileSync(readmePath, `${content.trimEnd()}\n`, 'utf8');
 }
 
-function restoreKnownWebProbes(targetRoot, previousAppContent) {
-  if (!previousAppContent) {
+function restoreManagedWebProbes(targetRoot, definitions) {
+  if (!Array.isArray(definitions) || definitions.length === 0) {
     return;
   }
 
-  const filePath = path.join(targetRoot, 'apps', 'web', 'src', 'App.tsx');
-  if (!fs.existsSync(filePath)) {
+  const probesFilePath = path.join(targetRoot, 'apps', 'web', 'src', 'probes.ts');
+  if (!fs.existsSync(probesFilePath)) {
     return;
   }
 
-  let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
-
-  const ensureProbeState = (stateLine) => {
-    if (content.includes(stateLine)) {
-      return;
-    }
-    const anchors = [
-      '  const [rbacProbeResult, setRbacProbeResult] = useState<ProbeResult | null>(null);',
-      '  const [rateLimitProbeResult, setRateLimitProbeResult] = useState<ProbeResult | null>(null);',
-      '  const [authProbeResult, setAuthProbeResult] = useState<ProbeResult | null>(null);',
-      '  const [dbProbeResult, setDbProbeResult] = useState<ProbeResult | null>(null);',
-      '  const [validationProbeResult, setValidationProbeResult] = useState<ProbeResult | null>(null);',
-    ];
-    const anchor = anchors.find((line) => content.includes(line));
-    if (anchor) {
-      content = ensureLineAfter(content, anchor, stateLine);
-    }
-  };
-
-  const ensureProbeButton = (buttonText, buttonCode) => {
-    if (content.includes(buttonText)) {
-      return;
-    }
-    const actionsStart = content.indexOf('<div className="actions">');
-    if (actionsStart < 0) {
-      return;
-    }
-    const actionsEnd = content.indexOf('\n      </div>', actionsStart);
-    if (actionsEnd < 0) {
-      return;
-    }
-    content = `${content.slice(0, actionsEnd)}\n${buttonCode}${content.slice(actionsEnd)}`;
-  };
-
-  const ensureProbeResult = (resultLine) => {
-    if (content.includes(resultLine)) {
-      return;
-    }
-    const networkLine = '      {networkError ? <p className="error">{networkError}</p> : null}';
-    if (content.includes(networkLine)) {
-      content = content.replace(networkLine, `${resultLine}\n${networkLine}`);
-      return;
-    }
-    const anchors = [
-      "      {renderResult('RBAC probe response', rbacProbeResult)}",
-      "      {renderResult('Rate limit probe response', rateLimitProbeResult)}",
-      "      {renderResult('Auth probe response', authProbeResult)}",
-      "      {renderResult('DB probe response', dbProbeResult)}",
-      "      {renderResult('Validation probe response', validationProbeResult)}",
-    ];
-    const anchor = anchors.find((line) => content.includes(line));
-    if (anchor) {
-      content = ensureLineAfter(content, anchor, resultLine);
-    }
+  const probeTargets = {
+    allowWeb: true,
+    probesFilePath,
   };
 
-  if (previousAppContent.includes('Check database (create user)')) {
-    ensureProbeState('  const [dbProbeResult, setDbProbeResult] = useState<ProbeResult | null>(null);');
-    ensureProbeButton(
-      'Check database (create user)',
-      "        <button onClick={() => runProbe(setDbProbeResult, '/health/db', { method: 'POST' })}>\n          Check database (create user)\n        </button>",
-    );
-    ensureProbeResult("      {renderResult('DB probe response', dbProbeResult)}");
-  }
-
-  if (previousAppContent.includes('Check JWT auth probe')) {
-    ensureProbeState('  const [authProbeResult, setAuthProbeResult] = useState<ProbeResult | null>(null);');
-    ensureProbeButton(
-      'Check JWT auth probe',
-      "        <button onClick={() => runProbe(setAuthProbeResult, '/health/auth')}>Check JWT auth probe</button>",
-    );
-    ensureProbeResult("      {renderResult('Auth probe response', authProbeResult)}");
-  }
-
-  if (previousAppContent.includes('Check rate limit (click repeatedly)')) {
-    ensureProbeState(
-      '  const [rateLimitProbeResult, setRateLimitProbeResult] = useState<ProbeResult | null>(null);',
-    );
-    ensureProbeButton(
-      'Check rate limit (click repeatedly)',
-      "        <button onClick={() => runProbe(setRateLimitProbeResult, '/health/rate-limit')}>\n          Check rate limit (click repeatedly)\n        </button>",
-    );
-    ensureProbeResult("      {renderResult('Rate limit probe response', rateLimitProbeResult)}");
+  for (const definition of definitions) {
+    ensureWebProbeDefinition({
+      targetRoot,
+      probeTargets,
+      definition,
+    });
   }
-
-  if (previousAppContent.includes('Check RBAC access')) {
-    ensureProbeState('  const [rbacProbeResult, setRbacProbeResult] = useState<ProbeResult | null>(null);');
-    ensureProbeButton(
-      'Check RBAC access',
-      "        <button\n          onClick={() =>\n            runProbe(setRbacProbeResult, '/health/rbac', {\n              headers: { 'x-forgeon-permissions': 'health.rbac' },\n            })\n          }\n        >\n          Check RBAC access\n        </button>",
-    );
-    ensureProbeResult("      {renderResult('RBAC probe response', rbacProbeResult)}");
-  }
-
-  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
 }
 
 export function applyI18nModule({ packageRoot, targetRoot }) {
-  const existingWebAppPath = path.join(targetRoot, 'apps', 'web', 'src', 'App.tsx');
-  const previousAppContent = fs.existsSync(existingWebAppPath)
-    ? fs.readFileSync(existingWebAppPath, 'utf8')
-    : '';
+  const previousProbeDefinitions = readManagedWebProbeDefinitions(targetRoot);
 
   copyFromBase(packageRoot, targetRoot, path.join('scripts', 'i18n-add.mjs'));
   copyFromBase(packageRoot, targetRoot, path.join('packages', 'i18n'));
@@ -568,10 +463,11 @@ export function applyI18nModule({ packageRoot, targetRoot }) {
 
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'i18n-contracts'));
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'i18n-web'));
+  copyFromBase(packageRoot, targetRoot, path.join('apps', 'web', 'src', 'probes.ts'));
   copyFromPreset(packageRoot, targetRoot, path.join('apps', 'web', 'src', 'App.tsx'));
   copyFromPreset(packageRoot, targetRoot, path.join('apps', 'web', 'src', 'i18n.ts'));
   copyFromPreset(packageRoot, targetRoot, path.join('apps', 'web', 'src', 'main.tsx'));
-  restoreKnownWebProbes(targetRoot, previousAppContent);
+  restoreManagedWebProbes(targetRoot, previousProbeDefinitions);
 
   patchI18nPackage(targetRoot);
   patchApiPackage(targetRoot);

package/src/modules/idempotency.test.mjs

@@ -0,0 +1,180 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { addModule } from './executor.mjs';
+import { scaffoldProject } from '../core/scaffold.mjs';
+
+function makeTempDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function readFile(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function scaffoldBaseProject({ packageRoot, targetRoot, projectName, dbPrismaEnabled, proxy = 'caddy' }) {
+  const templateRoot = path.join(packageRoot, 'templates', 'base');
+  scaffoldProject({
+    templateRoot,
+    packageRoot,
+    targetRoot,
+    projectName,
+    frontend: 'react',
+    db: 'prisma',
+    dbPrismaEnabled,
+    i18nEnabled: false,
+    proxy,
+  });
+}
+
+function readProjectSnapshot(projectRoot) {
+  const snapshot = {};
+  const queue = [projectRoot];
+  const skipDirs = new Set(['node_modules', '.git', 'dist', 'build']);
+
+  while (queue.length > 0) {
+    const currentDir = queue.shift();
+    const entries = fs
+      .readdirSync(currentDir, { withFileTypes: true })
+      .sort((left, right) => left.name.localeCompare(right.name));
+
+    for (const entry of entries) {
+      const nextPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          queue.push(nextPath);
+        }
+        continue;
+      }
+
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      snapshot[path.relative(projectRoot, nextPath)] = readFile(nextPath);
+    }
+  }
+
+  return Object.fromEntries(
+    Object.entries(snapshot).sort(([left], [right]) => left.localeCompare(right)),
+  );
+}
+
+describe('addModule idempotency', () => {
+  const modulesDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path.resolve(modulesDir, '..', '..');
+  const scenarios = [
+    {
+      name: 'logger',
+      moduleId: 'logger',
+      dbPrismaEnabled: true,
+      setup: [],
+      verify(projectRoot) {
+        assert.equal(fs.existsSync(path.join(projectRoot, 'packages', 'logger', 'package.json')), true);
+        assert.match(
+          readFile(path.join(projectRoot, 'apps', 'api', 'src', 'main.ts')),
+          /app\.useLogger\(app\.get\(ForgeonLoggerService\)\);/,
+        );
+      },
+    },
+    {
+      name: 'accounts',
+      moduleId: 'accounts',
+      dbPrismaEnabled: true,
+      setup: [],
+      verify(projectRoot) {
+        assert.equal(fs.existsSync(path.join(projectRoot, 'packages', 'accounts-api', 'package.json')), true);
+        assert.equal(
+          fs.existsSync(
+            path.join(projectRoot, 'apps', 'api', 'src', 'accounts', 'prisma-accounts-persistence.store.ts'),
+          ),
+          true,
+        );
+        assert.match(
+          readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts')),
+          /@Get\('auth'\)/,
+        );
+        assert.match(
+          readFile(path.join(projectRoot, 'apps', 'api', 'src', 'app.module.ts')),
+          /ForgeonAccountsModule\.register\(/,
+        );
+      },
+    },
+    {
+      name: 'files-local',
+      moduleId: 'files-local',
+      dbPrismaEnabled: true,
+      setup: [],
+      verify(projectRoot) {
+        assert.equal(fs.existsSync(path.join(projectRoot, 'packages', 'files-local', 'package.json')), true);
+        assert.match(readFile(path.join(projectRoot, 'apps', 'api', '.env.example')), /FILES_LOCAL_ROOT=storage\/uploads/);
+        assert.match(readFile(path.join(projectRoot, 'infra', 'docker', 'compose.yml')), /^\s{2}files_data:\s*$/m);
+      },
+    },
+    {
+      name: 'files',
+      moduleId: 'files',
+      dbPrismaEnabled: true,
+      setup: ['files-local'],
+      verify(projectRoot) {
+        assert.equal(fs.existsSync(path.join(projectRoot, 'packages', 'files', 'package.json')), true);
+        assert.match(readFile(path.join(projectRoot, 'apps', 'api', '.env.example')), /FILES_STORAGE_DRIVER=local/);
+        assert.match(
+          readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts')),
+          /@Post\('files'\)/,
+        );
+      },
+    },
+    {
+      name: 'queue',
+      moduleId: 'queue',
+      dbPrismaEnabled: false,
+      setup: [],
+      verify(projectRoot) {
+        assert.equal(fs.existsSync(path.join(projectRoot, 'packages', 'queue', 'package.json')), true);
+        assert.match(readFile(path.join(projectRoot, 'infra', 'docker', 'compose.yml')), /^\s{2}redis:\s*$/m);
+        assert.match(
+          readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts')),
+          /@Get\('queue'\)/,
+        );
+      },
+    },
+  ];
+
+  it('reapplying representative implemented modules is a no-op on project files', () => {
+    for (const scenario of scenarios) {
+      const tempRoot = makeTempDir(`forgeon-idempotent-${scenario.name}-`);
+      const projectRoot = path.join(tempRoot, `demo-${scenario.name}`);
+
+      try {
+        scaffoldBaseProject({
+          packageRoot,
+          targetRoot: projectRoot,
+          projectName: `demo-${scenario.name}`,
+          dbPrismaEnabled: scenario.dbPrismaEnabled,
+        });
+
+        for (const moduleId of scenario.setup) {
+          addModule({ moduleId, targetRoot: projectRoot, packageRoot });
+        }
+
+        const firstResult = addModule({ moduleId: scenario.moduleId, targetRoot: projectRoot, packageRoot });
+        assert.equal(firstResult.applied, true);
+        scenario.verify(projectRoot);
+
+        const before = readProjectSnapshot(projectRoot);
+        const secondResult = addModule({ moduleId: scenario.moduleId, targetRoot: projectRoot, packageRoot });
+        const after = readProjectSnapshot(projectRoot);
+
+        assert.equal(secondResult.applied, true);
+        assert.deepEqual(after, before);
+        scenario.verify(projectRoot);
+      } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+      }
+    }
+  });
+});

package/src/modules/logger.mjs

@@ -44,10 +44,6 @@ function patchMain(targetRoot) {
   }
 
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
-  content = content.replace(
-    "import { ForgeonHttpLoggingInterceptor, ForgeonLoggerService } from '@forgeon/logger';",
-    "import { ForgeonLoggerService } from '@forgeon/logger';",
-  );
   content = ensureLineBefore(
     content,
     "import { NestFactory } from '@nestjs/core';",
@@ -59,11 +55,6 @@ function patchMain(targetRoot) {
     'const app = await NestFactory.create(AppModule, { bufferLogs: true });',
   );
 
-  content = content.replace(
-    /\n\s*app\.useGlobalInterceptors\(app\.get\(ForgeonHttpLoggingInterceptor\)\);\s*/g,
-    '\n',
-  );
-
   if (!content.includes('app.useLogger(app.get(ForgeonLoggerService));')) {
     content = content.replace(
       '  const coreConfigService = app.get(CoreConfigService);',

package/src/modules/probes.test.mjs

@@ -0,0 +1,204 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { addModule } from './executor.mjs';
+import { scaffoldProject } from '../core/scaffold.mjs';
+
+function makeTempDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function readFile(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function writeJson(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function scaffoldBaseProject({ packageRoot, targetRoot, projectName }) {
+  const templateRoot = path.join(packageRoot, 'templates', 'base');
+  scaffoldProject({
+    templateRoot,
+    packageRoot,
+    targetRoot,
+    projectName,
+    frontend: 'react',
+    db: 'prisma',
+    dbPrismaEnabled: false,
+    i18nEnabled: false,
+    proxy: 'caddy',
+  });
+}
+
+function readManagedProbeIds(projectRoot) {
+  const probesTs = readFile(path.join(projectRoot, 'apps', 'web', 'src', 'probes.ts'));
+  const match = probesTs.match(/forgeon:module-probes:start(?:\n([\s\S]*?))?\n  \/\/ forgeon:module-probes:end/);
+  const block = match?.[1] ?? '';
+  return [...block.matchAll(/"id": "([^"]+)"/g)].map((item) => item[1]);
+}
+
+function captureLogs(work) {
+  const lines = [];
+  const originalLog = console.log;
+  console.log = (...args) => {
+    lines.push(args.join(' '));
+  };
+
+  try {
+    work();
+  } finally {
+    console.log = originalLog;
+  }
+
+  return lines.join('\n');
+}
+
+describe('probe wiring', () => {
+  const modulesDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path.resolve(modulesDir, '..', '..');
+
+  it('skips API and web probe wiring when probes are disabled in package.json', () => {
+    const tempRoot = makeTempDir('forgeon-probes-disabled-');
+    const projectRoot = path.join(tempRoot, 'demo-probes-disabled');
+
+    try {
+      scaffoldBaseProject({
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-probes-disabled',
+      });
+
+      const packagePath = path.join(projectRoot, 'package.json');
+      const packageJson = JSON.parse(readFile(packagePath));
+      packageJson.forgeon.diagnostics.probes.enabled = false;
+      writeJson(packagePath, packageJson);
+
+      const output = captureLogs(() => {
+        addModule({ moduleId: 'queue', targetRoot: projectRoot, packageRoot });
+      });
+
+      const healthController = readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts'));
+      assert.doesNotMatch(healthController, /@Get\('queue'\)/);
+      assert.doesNotMatch(readFile(path.join(projectRoot, 'apps', 'web', 'src', 'probes.ts')), /"id": "queue"/);
+      assert.match(output, /forgeon\.diagnostics\.probes\.enabled=false/);
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips probe wiring entirely when HealthController is missing', () => {
+    const tempRoot = makeTempDir('forgeon-probes-no-health-');
+    const projectRoot = path.join(tempRoot, 'demo-probes-no-health');
+
+    try {
+      scaffoldBaseProject({
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-probes-no-health',
+      });
+
+      fs.rmSync(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts'));
+
+      const output = captureLogs(() => {
+        addModule({ moduleId: 'queue', targetRoot: projectRoot, packageRoot });
+      });
+
+      assert.equal(
+        fs.existsSync(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts')),
+        false,
+      );
+      assert.doesNotMatch(readFile(path.join(projectRoot, 'apps', 'web', 'src', 'probes.ts')), /"id": "queue"/);
+      assert.match(output, /health\.controller\.ts is missing/);
+      assert.doesNotMatch(output, /App\.tsx/);
+      assert.doesNotMatch(output, /#probes/);
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('adds only API probes when App.tsx is missing', () => {
+    const tempRoot = makeTempDir('forgeon-probes-no-app-');
+    const projectRoot = path.join(tempRoot, 'demo-probes-no-app');
+
+    try {
+      scaffoldBaseProject({
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-probes-no-app',
+      });
+
+      fs.rmSync(path.join(projectRoot, 'apps', 'web', 'src', 'App.tsx'));
+
+      const output = captureLogs(() => {
+        addModule({ moduleId: 'queue', targetRoot: projectRoot, packageRoot });
+      });
+
+      const healthController = readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts'));
+      assert.match(healthController, /@Get\('queue'\)/);
+      assert.doesNotMatch(readFile(path.join(projectRoot, 'apps', 'web', 'src', 'probes.ts')), /"id": "queue"/);
+      assert.match(output, /App\.tsx is missing/);
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('adds only API probes when the #probes container is missing', () => {
+    const tempRoot = makeTempDir('forgeon-probes-no-container-');
+    const projectRoot = path.join(tempRoot, 'demo-probes-no-container');
+
+    try {
+      scaffoldBaseProject({
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-probes-no-container',
+      });
+
+      const appPath = path.join(projectRoot, 'apps', 'web', 'src', 'App.tsx');
+      const appTsx = readFile(appPath).replace('id="probes"', 'id="diagnostics"');
+      fs.writeFileSync(appPath, appTsx, 'utf8');
+
+      const output = captureLogs(() => {
+        addModule({ moduleId: 'rate-limit', targetRoot: projectRoot, packageRoot });
+      });
+
+      const healthController = readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts'));
+      assert.match(healthController, /@Get\('rate-limit'\)/);
+      assert.doesNotMatch(readFile(path.join(projectRoot, 'apps', 'web', 'src', 'probes.ts')), /"id": "rate-limit"/);
+      assert.match(output, /#probes container/);
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps managed probe order stable regardless of install order', () => {
+    const tempRoot = makeTempDir('forgeon-probes-order-');
+    const projectRoot = path.join(tempRoot, 'demo-probes-order');
+
+    try {
+      scaffoldBaseProject({
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-probes-order',
+      });
+
+      addModule({ moduleId: 'queue', targetRoot: projectRoot, packageRoot });
+      addModule({ moduleId: 'scheduler', targetRoot: projectRoot, packageRoot });
+      addModule({ moduleId: 'db-prisma', targetRoot: projectRoot, packageRoot });
+      addModule({ moduleId: 'accounts', targetRoot: projectRoot, packageRoot });
+      addModule({ moduleId: 'rate-limit', targetRoot: projectRoot, packageRoot });
+
+      assert.deepEqual(readManagedProbeIds(projectRoot), ['db', 'auth', 'rate-limit', 'queue', 'scheduler']);
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+});
+
+
+
+
+