@nocobase/app-template-default 0.0.0-stage → 1.0.0-beta.58

package/tests/logic/dev-client-watch.test.ts

@@ -0,0 +1,108 @@
+// @vitest-environment node
+
+import {
+  copyFile,
+  mkdir,
+  mkdtemp,
+  realpath,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createServer, type ViteDevServer } from 'vite';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const appRoot = path.resolve(import.meta.dirname, '../..');
+let workspace: string | undefined;
+let server: ViteDevServer | undefined;
+
+afterEach(async () => {
+  await server?.close();
+  server = undefined;
+  if (workspace) await rm(workspace, { recursive: true, force: true });
+  workspace = undefined;
+  vi.unstubAllEnvs();
+});
+
+describe('development client file watching', () => {
+  it('skips the complete app build while watching client and linked dependency edits', async () => {
+    workspace = await realpath(
+      await mkdtemp(path.join(tmpdir(), 'nocobase-client-watch-')),
+    );
+    // Brackets also guard against accidentally interpreting the app path as a glob.
+    const root = path.join(workspace, 'app [fixture]');
+    const clientFile = path.join(root, 'client/main.js');
+    const dependencyDirectory = path.join(
+      workspace,
+      'linked-plugin/dist/client',
+    );
+    const dependencyFile = path.join(dependencyDirectory, 'index.js');
+    const files = [
+      clientFile,
+      dependencyFile,
+      path.join(root, 'dist/client/index.js'),
+      path.join(root, 'dist/server/index.js'),
+      path.join(root, 'dist/vendor/plugin/dist/client/index.js'),
+      path.join(root, 'dist-sources/index.js'),
+    ];
+    for (const file of files) {
+      await mkdir(path.dirname(file), { recursive: true });
+      await writeFile(file, 'export const value = 1;\n');
+    }
+    for (const file of ['vite.config.ts', 'package.json']) {
+      await copyFile(path.join(appRoot, file), path.join(root, file));
+    }
+    await symlink(
+      path.join(appRoot, 'node_modules'),
+      path.join(root, 'node_modules'),
+      'junction',
+    );
+
+    vi.stubEnv('AGENT_ANNOTATIONS_ENABLED', 'false');
+    vi.stubEnv('PROXY_TARGET_URL', '');
+    // `pnpm dev` always passes the mount path; the Vite preset refuses to serve without one.
+    vi.stubEnv('APP_BASE_PATH', '/main');
+    server = await createServer({
+      root,
+      // node_modules is shared with the running app; keep optimizer writes local.
+      cacheDir: path.join(workspace, 'vite-cache'),
+      configFile: path.join(root, 'vite.config.ts'),
+      logLevel: 'silent',
+      optimizeDeps: { noDiscovery: true, include: [] },
+      server: {
+        middlewareMode: true,
+        // Poll this small fixture so change events are reliable across CI hosts.
+        watch: { usePolling: true, interval: 20 },
+      },
+    });
+    const watcher = server.watcher;
+    const changes: string[] = [];
+    watcher.on('change', (file) => changes.push(file));
+    // Vite adds imported modules outside the app root to this same watcher.
+    watcher.add(dependencyDirectory);
+    await vi.waitFor(() => {
+      const watched = watcher.getWatched();
+      expect(watched[path.dirname(clientFile)]).toContain('main.js');
+      expect(watched[dependencyDirectory]).toContain('index.js');
+      expect(watched[path.join(root, 'dist-sources')]).toContain('index.js');
+    });
+
+    await writeFile(clientFile, 'export const value = 2;\n');
+    await writeFile(dependencyFile, 'export const value = 2;\n');
+    await vi.waitFor(() => {
+      expect(changes).toContain(clientFile);
+      expect(changes).toContain(dependencyFile);
+    });
+
+    const watchedDirectories = Object.keys(watcher.getWatched());
+    expect(
+      watchedDirectories.filter(
+        (directory) =>
+          directory === path.join(root, 'dist') ||
+          directory.startsWith(path.join(root, 'dist') + path.sep),
+      ),
+    ).toEqual([]);
+  });
+});

package/tests/logic/dev-routes-production-build.test.ts

@@ -0,0 +1,168 @@
+// @vitest-environment node
+// Vite's esbuild dependency asserts that `new TextEncoder().encode('')` yields a real Uint8Array, which jsdom's
+// globals break. This file drives an actual production build, so it runs under Node rather than the shared jsdom
+// environment the React tests use.
+import {
+  mkdtemp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { findPackageJSON } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { build } from 'vite';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+/**
+ * The guarantee under test is a build-time one: nothing a plugin declares through `defineDevRoutes()` may reach a
+ * production bundle. A unit test cannot show that — only a real production build can, because the guarantee comes
+ * from Vite replacing `import.meta.env.PROD` with `true` and then dropping the branch that becomes unreachable.
+ *
+ * The fixture builds against the real `@nocobase/app-client` helpers rather than a stand-in, so the test fails if the
+ * guard inside `defineDevRoutes()` is ever weakened.
+ */
+
+const appClientPackagePath = findPackageJSON(
+  '@nocobase/app-client',
+  import.meta.url,
+);
+if (!appClientPackagePath) {
+  throw new Error('Cannot resolve @nocobase/app-client/package.json');
+}
+const appClientPackage = JSON.parse(
+  readFileSync(appClientPackagePath, 'utf8'),
+) as { exports?: { './plugins'?: { import?: string } } };
+const appClientPluginsExport = appClientPackage.exports?.['./plugins']?.import;
+if (!appClientPluginsExport) {
+  throw new Error('@nocobase/app-client does not export ./plugins');
+}
+const appClientPlugins = path.resolve(
+  path.dirname(appClientPackagePath),
+  appClientPluginsExport,
+);
+
+const DEV_PAGE_MARKER = 'dev_page_marker_a7f3c1';
+const DEV_ONLY_DEPENDENCY_MARKER = 'dev_only_dependency_marker_a7f3c1';
+const SETTINGS_PAGE_MARKER = 'settings_page_marker_a7f3c1';
+
+let workspace: string;
+let bundle: string;
+
+async function readBundle(outputDirectory: string): Promise<string> {
+  const entries = await readdir(outputDirectory, {
+    recursive: true,
+    withFileTypes: true,
+  });
+  const files = entries.filter((entry) => entry.isFile());
+  const contents = await Promise.all(
+    files.map((entry) =>
+      readFile(path.join(entry.parentPath, entry.name), 'utf8'),
+    ),
+  );
+  return contents.join('\n');
+}
+
+beforeAll(async () => {
+  workspace = await mkdtemp(path.join(tmpdir(), 'nocobase-dev-routes-'));
+  const source = path.join(workspace, 'src');
+  await mkdir(source, { recursive: true });
+
+  await writeFile(
+    path.join(source, 'dev-only-dependency.ts'),
+    `export const devOnlyDependency = '${DEV_ONLY_DEPENDENCY_MARKER}';\n`,
+  );
+  await writeFile(
+    path.join(source, 'dev-page.tsx'),
+    `import { devOnlyDependency } from './dev-only-dependency.js';\n\n` +
+      `export default function DevPage() {\n` +
+      `  return '${DEV_PAGE_MARKER}' + devOnlyDependency;\n` +
+      `}\n`,
+  );
+  await writeFile(
+    path.join(source, 'settings-page.tsx'),
+    `export default function SettingsPage() {\n` +
+      `  return '${SETTINGS_PAGE_MARKER}';\n` +
+      `}\n`,
+  );
+  // The entry mirrors how a plugin declares both surfaces side by side, so the settings page acts as the control: it
+  // must survive exactly the build that drops the dev page.
+  await writeFile(
+    path.join(source, 'main.ts'),
+    `import { defineDevRoutes, defineSettingsRoutes } from '@nocobase/app-client/plugins';\n\n` +
+      `const routes = [\n` +
+      `  defineSettingsRoutes([\n` +
+      `    {\n` +
+      `      name: 'settings-page',\n` +
+      `      path: '/settings-page',\n` +
+      `      navigation: { title: 'Settings page' },\n` +
+      `      componentLoader: () => import('./settings-page.js'),\n` +
+      `    },\n` +
+      `  ]),\n` +
+      `  defineDevRoutes([\n` +
+      `    {\n` +
+      `      name: 'dev-page',\n` +
+      `      path: '/dev-page',\n` +
+      `      navigation: { title: 'Dev page' },\n` +
+      `      componentLoader: () => import('./dev-page.js'),\n` +
+      `    },\n` +
+      `  ]),\n` +
+      `];\n\n` +
+      `globalThis.__routes = routes;\n`,
+  );
+
+  // Vite decides `import.meta.env.PROD` from NODE_ENV, not from the build mode. Vitest sets NODE_ENV=test, under
+  // which Vite treats even `mode: 'production'` as a non-production build and leaves the dev branch in place — so the
+  // variable has to be set for the duration of the build, or this test would assert against a development bundle.
+  const previousNodeEnv = process.env.NODE_ENV;
+  process.env.NODE_ENV = 'production';
+  try {
+    await build({
+      root: workspace,
+      logLevel: 'silent',
+      resolve: {
+        alias: [
+          {
+            find: '@nocobase/app-client/plugins',
+            replacement: appClientPlugins,
+          },
+        ],
+      },
+      build: {
+        outDir: 'dist',
+        rollupOptions: { input: path.join(source, 'main.ts') },
+      },
+    });
+  } finally {
+    if (previousNodeEnv === undefined) {
+      delete process.env.NODE_ENV;
+    } else {
+      process.env.NODE_ENV = previousNodeEnv;
+    }
+  }
+
+  bundle = await readBundle(path.join(workspace, 'dist'));
+}, 120_000);
+
+afterAll(async () => {
+  if (workspace) {
+    await rm(workspace, { recursive: true, force: true });
+  }
+});
+
+describe('dev routes in a production build', () => {
+  it('builds the settings page that acts as the control', () => {
+    expect(bundle).toContain(SETTINGS_PAGE_MARKER);
+  });
+
+  it('drops the dev page component', () => {
+    expect(bundle).not.toContain(DEV_PAGE_MARKER);
+  });
+
+  it('drops a module only a dev page imports', () => {
+    expect(bundle).not.toContain(DEV_ONLY_DEPENDENCY_MARKER);
+  });
+});

package/tests/logic/device-code-migration.test.ts

@@ -0,0 +1,70 @@
+// @vitest-environment node
+import path from 'node:path';
+import type { MigrationSource } from '@nocobase/db';
+import { describeMigration } from '@nocobase/app-testing/server';
+import { expect } from 'vitest';
+
+const sources: readonly MigrationSource[] = [
+  {
+    packageName: 'device-code-test',
+    directory: path.resolve(
+      import.meta.dirname,
+      '../../database/main/migrations',
+    ),
+  },
+];
+
+// The table Better Auth's `deviceAuthorization()` reads and writes (`server/config/auth.ts`).
+describeMigration('202610060001_create_device_code', {
+  sources,
+  up: async ({ connection, expectCollection }) => {
+    const deviceCode = await expectCollection('deviceCode').toExist();
+    expect(Object.keys(deviceCode.fields)).toEqual([
+      'id',
+      'deviceCode',
+      'userCode',
+      'userId',
+      'expiresAt',
+      'status',
+      'lastPolledAt',
+      'pollingInterval',
+      'clientId',
+      'scope',
+    ]);
+    expect(deviceCode.primaryKey).toEqual(['id']);
+    await expectCollection('deviceCode').toHaveField('userId', {
+      nullable: true,
+    });
+    await expectCollection('deviceCode').toHaveField('expiresAt', {
+      nullable: false,
+    });
+    const row = {
+      deviceCode: 'device-1',
+      userCode: 'WXYZ2345',
+      expiresAt: new Date(),
+      status: 'pending',
+      pollingInterval: 5000,
+      clientId: 'cli',
+    };
+    await connection.query
+      .insertInto('deviceCode')
+      .values({ ...row, id: 'a' })
+      .execute();
+    // Both codes are unique.
+    await expect(
+      connection.query
+        .insertInto('deviceCode')
+        .values({ ...row, id: 'b', userCode: 'OTHER234' })
+        .execute(),
+    ).rejects.toThrow();
+    await expect(
+      connection.query
+        .insertInto('deviceCode')
+        .values({ ...row, id: 'c', deviceCode: 'device-2' })
+        .execute(),
+    ).rejects.toThrow();
+  },
+  down: async ({ expectCollection }) => {
+    await expectCollection('deviceCode').not.toExist();
+  },
+});

package/tests/logic/lifecycle.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  RealtimeProvider,
+  realtimeServiceToken,
+} from '@nocobase/app-server/realtime';
+import {
+  ServiceContainer,
+  ServiceProviderRegistry,
+} from '@nocobase/service-provider';
+import { createDefaultCachingConfig } from '@nocobase/caching';
+import { CachingProvider, cachingToken } from '@nocobase/app-server/caching';
+import type { AppConfigAccessor } from '@nocobase/app-server/config';
+import { DriveProvider, driveManagerToken } from '@nocobase/app-server/drive';
+import {
+  IdGeneratorProvider,
+  idGeneratorToken,
+} from '@nocobase/app-server/id-generator';
+import { LoggingProvider, loggingToken } from '@nocobase/app-server/logging';
+import {
+  QueueServiceProvider,
+  queueServiceToken,
+} from '@nocobase/app-server/queue';
+import {
+  SessionProvider,
+  sessionManagerToken,
+} from '@nocobase/app-server/session';
+import { createNullSessionConfig } from '@nocobase/session';
+import { databaseManagerToken, type DatabaseManager } from '@nocobase/db';
+
+describe('app service providers', () => {
+  it('registers core services and shuts them down in reverse order', async () => {
+    const services = new ServiceContainer();
+    const registry = new ServiceProviderRegistry();
+    const app = createProviderApplication(
+      {
+        caching: createDefaultCachingConfig(),
+        drive: {
+          default: 'local',
+          disks: {
+            local: {
+              driver: 'fs',
+              location: process.cwd(),
+              visibility: 'private',
+            },
+          },
+        },
+        logging: {
+          enabled: false,
+          level: 'silent',
+        },
+        queue: {
+          default: 'memory',
+          memory: { adapter: 'inMemory' },
+        },
+        session: createNullSessionConfig(),
+        snowflake: {
+          workerId: 0,
+        },
+      },
+      services,
+    );
+    registry.add(new LoggingProvider(app));
+    registry.add(new CachingProvider(app));
+    registry.add(new IdGeneratorProvider(app));
+    registry.add(new SessionProvider(app));
+    registry.add(new DriveProvider(app));
+    registry.add(new QueueServiceProvider(app));
+    registry.add(new RealtimeProvider(app));
+
+    registry.registerAll();
+    const logging = services.resolve(loggingToken);
+    const caching = services.resolve(cachingToken);
+    const idGenerator = services.resolve(idGeneratorToken);
+    const sessionManager = services.resolve(sessionManagerToken);
+    const queue = services.resolve(queueServiceToken);
+    const realtime = services.resolve(realtimeServiceToken);
+    const closeLogging = vi.spyOn(logging, 'close');
+    const dispose = vi.spyOn(caching, 'dispose');
+    const disposeSession = vi.spyOn(sessionManager, 'dispose');
+    const closeQueue = vi.spyOn(queue, 'shutdown');
+    const closeRealtime = vi.spyOn(realtime, 'close');
+
+    await registry.shutdown();
+
+    expect(services.resolve(idGeneratorToken)).toBe(idGenerator);
+    expect(services.has(driveManagerToken)).toBe(true);
+    expect(closeRealtime).toHaveBeenCalledOnce();
+    expect(closeQueue).toHaveBeenCalledOnce();
+    expect(disposeSession).toHaveBeenCalledOnce();
+    expect(dispose).toHaveBeenCalledOnce();
+    expect(closeLogging).toHaveBeenCalledOnce();
+    expect(disposeSession.mock.invocationCallOrder[0]).toBeLessThan(
+      dispose.mock.invocationCallOrder[0],
+    );
+    expect(closeQueue.mock.invocationCallOrder[0]).toBeLessThan(
+      disposeSession.mock.invocationCallOrder[0],
+    );
+    expect(closeRealtime.mock.invocationCallOrder[0]).toBeLessThan(
+      closeQueue.mock.invocationCallOrder[0],
+    );
+    expect(dispose.mock.invocationCallOrder[0]).toBeLessThan(
+      closeLogging.mock.invocationCallOrder[0],
+    );
+  });
+
+  it('registers and prepares drive only when configuration is available', async () => {
+    const services = new ServiceContainer();
+    const registry = new ServiceProviderRegistry();
+    registry.add(
+      new DriveProvider({
+        config: createTestConfig({
+          drive: {
+            default: 'public',
+            disks: {
+              public: {
+                driver: 'fs',
+                location: process.cwd(),
+                visibility: 'public',
+              },
+            },
+          },
+        }),
+        container: services,
+      }),
+    );
+
+    registry.registerAll();
+    await registry.bootAll();
+
+    expect(services.has(driveManagerToken)).toBe(true);
+    expect(services.resolve(driveManagerToken)).toBeDefined();
+  });
+
+  it('resolves authentication, authorization, and queue provider dependencies', async () => {
+    const services = new ServiceContainer();
+    const registry = new ServiceProviderRegistry();
+    const connection = { kind: 'connection' };
+    const database = {
+      connection: vi.fn(() => connection),
+      destroy: vi.fn(() => Promise.resolve()),
+    } as unknown as DatabaseManager;
+    const queueConfig = {
+      default: 'test',
+      test: { adapter: 'inMemory' as const },
+    };
+    const app = createProviderApplication(
+      {
+        database: createDatabaseConfig(),
+        app: {
+          name: 'provider-test',
+          publicOrigin: 'https://example.com',
+          publicBasePath: '/provider-test',
+        },
+        auth: {
+          secret: 'test-auth-secret-at-least-32-characters',
+        },
+        caching: createDefaultCachingConfig(),
+        logging: {
+          enabled: false,
+          level: 'silent',
+        },
+        queue: queueConfig,
+        snowflake: {
+          workerId: 0,
+        },
+      },
+      services,
+    );
+    services.instance(databaseManagerToken, database);
+    registry.add(new LoggingProvider(app));
+    registry.add(new CachingProvider(app));
+    registry.add(new IdGeneratorProvider(app));
+    registry.add(new QueueServiceProvider(app));
+
+    registry.registerAll();
+    services.resolve(queueServiceToken);
+
+    expect(services.resolve(databaseManagerToken)).toBe(database);
+    await registry.shutdown();
+  });
+});
+
+function createProviderApplication(
+  values: Readonly<Record<string, unknown>>,
+  container: ServiceContainer,
+): {
+  appName: string;
+  paths: { storage: (...segments: string[]) => string };
+  config: AppConfigAccessor;
+  container: ServiceContainer;
+} {
+  return {
+    appName: 'provider-test',
+    paths: { storage: (...segments: string[]) => segments.join('/') },
+    config: createTestConfig(values),
+    container,
+  };
+}
+
+function createTestConfig(
+  values: Readonly<Record<string, unknown>>,
+): AppConfigAccessor {
+  return {
+    get: <TValue>(definition: string): TValue => values[definition] as TValue,
+    raw: () => values,
+    reload: () => Promise.resolve({ changedNamespaces: [] }),
+    subscribe: () => () => undefined,
+  };
+}
+
+function createDatabaseConfig(): object {
+  return {
+    default: 'main',
+    connections: {},
+    migrations: {
+      directory: '',
+      autoRun: false,
+    },
+  };
+}

package/tests/logic/plugin-commands.test.ts

@@ -0,0 +1,69 @@
+// @vitest-environment node
+
+// Users develop, build and start their app through these scripts. Nothing at runtime depends on them, so dropping or
+// renaming one — a bad merge resolution did exactly that once — breaks the documented workflow silently: the app still
+// builds, starts, and passes every other test. These assertions are the alarm.
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+const appRoot = fileURLToPath(new URL('../..', import.meta.url));
+
+interface AppPackageJson {
+  readonly files?: readonly string[];
+  readonly publishConfig?: unknown;
+  readonly scripts?: Record<string, string>;
+  readonly dependencies?: Record<string, string>;
+  readonly devDependencies?: Record<string, string>;
+}
+
+const appPackage = JSON.parse(
+  readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
+) as AppPackageJson;
+
+const scripts = appPackage.scripts ?? {};
+
+/**
+ * The scripts an application keeps. Every other command is `pnpm nocobase <topic> <command>`, which pnpm resolves to
+ * the `nocobase` bin without a script, so a script alias would only be a second name to keep in step.
+ */
+const LIFECYCLE_SCRIPTS: Readonly<Record<string, string>> = {
+  postinstall: 'nocobase skills sync',
+  dev: 'nocobase dev',
+  build: 'nocobase build',
+  start: 'nocobase start',
+};
+
+describe('application scripts', () => {
+  it.each(Object.entries(LIFECYCLE_SCRIPTS))('exposes %s', (name, command) => {
+    expect(scripts[name]).toBe(command);
+  });
+
+  it('keeps no alias for a CLI command', () => {
+    const aliases = Object.entries(scripts).filter(
+      ([name, command]) =>
+        !(name in LIFECYCLE_SCRIPTS) && /(^|&&\s*)nocobase\s/.test(command),
+    );
+    expect(aliases).toEqual([]);
+  });
+
+  it('declares the CLI the scripts invoke', () => {
+    // A runtime dependency, not tooling: a deployment runs `dist/cli/index.js`, which imports it, and installs from
+    // `dependencies` alone.
+    expect(appPackage.dependencies?.['@nocobase/app-cli']).toBeTruthy();
+  });
+
+  it('keeps synchronized Agent state out of source control and publication', () => {
+    expect(readFileSync(path.join(appRoot, '.gitignore'), 'utf8')).toContain(
+      '/.agents/',
+    );
+    const npmIgnorePath = path.join(appRoot, '.npmignore');
+    if (appPackage.publishConfig) {
+      expect(existsSync(npmIgnorePath)).toBe(true);
+      expect(readFileSync(npmIgnorePath, 'utf8')).toContain('.agents/');
+    }
+    expect(appPackage.files).not.toContain('.agents');
+  });
+});

package/tests/logic/plugin-page-authz.test.ts

@@ -0,0 +1,53 @@
+// @vitest-environment node
+
+import {
+  resolveAppClientContributions,
+  type AppClientRegisteredRoute,
+} from '@nocobase/app-client/plugins';
+import { describe, expect, it } from 'vitest';
+
+import clientPlugins from '../../client/plugins.js';
+
+// The plugins whose pages the permission workspace offers as page grants.
+const PAGE_GRANT_PLUGINS = [
+  '@nocobase/app-plugin-users',
+  '@nocobase/app-plugin-notification',
+  '@nocobase/app-plugin-api-keys',
+  '@nocobase/app-plugin-database-explorer',
+];
+
+describe('plugin page authorization', () => {
+  it('offers a page grant for each listed plugin', () => {
+    const resolved = resolveAppClientContributions(
+      clientPlugins.plugins.map((plugin) => ({
+        packageName: plugin.packageName,
+        source: 'plugin' as const,
+        routes: plugin.routes,
+      })),
+    );
+    const pages = entryPages([
+      ...resolved.routes,
+      ...resolved.settingsRouteTree,
+    ]).filter((route) => PAGE_GRANT_PLUGINS.includes(route.packageName));
+
+    // A page may check another resource type; each plugin still offers a page grant.
+    const granted = pages.filter(
+      (route) =>
+        typeof route.authz === 'object' &&
+        route.authz.resource.type === 'page' &&
+        route.authz.action === 'access',
+    );
+    expect(new Set(granted.map((route) => route.packageName))).toEqual(
+      new Set(PAGE_GRANT_PLUGINS),
+    );
+  });
+});
+
+/** Pages without a page above them: nested pages share their parent's check. */
+function entryPages(
+  routes: readonly AppClientRegisteredRoute[],
+): AppClientRegisteredRoute[] {
+  return routes.flatMap((route) =>
+    route.componentLoader ? [route] : entryPages(route.children ?? []),
+  );
+}