@jskit-ai/console-core 0.1.1

package/test/consoleSettingsService.test.js

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createService } from "../src/server/consoleSettings/consoleSettingsService.js";
+
+function createFixture({ deny = false } = {}) {
+  const calls = {
+    requireConsoleOwner: [],
+    updateSingleton: []
+  };
+
+  const service = createService({
+    consoleService: {
+      async requireConsoleOwner(context) {
+        calls.requireConsoleOwner.push(context || null);
+        if (deny) {
+          const error = new Error("Forbidden.");
+          error.status = 403;
+          throw error;
+        }
+      }
+    },
+    consoleSettingsRepository: {
+      async getSingleton() {
+        return {};
+      },
+      async updateSingleton(patch = {}) {
+        calls.updateSingleton.push({ ...patch });
+        return {};
+      }
+    }
+  });
+
+  return { service, calls };
+}
+
+test("consoleSettingsService.getSettings requires owner access and returns normalized payload", async () => {
+  const { service, calls } = createFixture();
+  const context = {
+    actor: {
+      id: 7
+    }
+  };
+
+  const response = await service.getSettings({ context });
+
+  assert.deepEqual(calls.requireConsoleOwner, [context]);
+  assert.deepEqual(response, {
+    settings: {}
+  });
+});
+
+test("consoleSettingsService.updateSettings requires owner access before writing", async () => {
+  const { service, calls } = createFixture();
+  const context = {
+    actor: {
+      id: 7
+    }
+  };
+
+  const response = await service.updateSettings(
+    {},
+    { context }
+  );
+
+  assert.deepEqual(calls.requireConsoleOwner, [context]);
+  assert.deepEqual(calls.updateSingleton, [{}]);
+  assert.deepEqual(response, {
+    settings: {}
+  });
+});
+
+test("consoleSettingsService denies access when owner validation fails", async () => {
+  const { service } = createFixture({ deny: true });
+
+  await assert.rejects(
+    () =>
+      service.getSettings({
+        context: {
+          actor: {
+            id: 9
+          }
+        }
+      }),
+    (error) => error?.status === 403
+  );
+});

package/test/exportsContract.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { evaluatePackageExportsContract } from "../../../tooling/test-support/exportsContract.mjs";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(TEST_DIRECTORY, "..", "..", "..");
+const PACKAGE_DIR = path.join(REPO_ROOT, "packages", "console-core");
+
+test("console-core exports are explicit and aligned with production/template usage", () => {
+  const result = evaluatePackageExportsContract({
+    repoRoot: REPO_ROOT,
+    packageDir: PACKAGE_DIR,
+    packageId: "@jskit-ai/console-core"
+  });
+
+  assert.deepEqual(result.wildcardExports, [], `console-core exports must be explicit. Remove wildcard keys: ${result.wildcardExports.join(", ")}`);
+  assert.deepEqual(
+    result.missingRequiredExports,
+    [],
+    `console-core required exports missing: ${result.missingRequiredExports.join(", ")}`
+  );
+  assert.deepEqual(result.missingExports, [], `console-core imports missing from package exports:\n${result.missingExports.join("\n")}`);
+  assert.deepEqual(result.staleExports, [], `Stale console-core exports found. Remove stale keys: ${result.staleExports.join(", ")}`);
+});

package/test/registerConsoleCore.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerConsoleCore } from "../src/server/registerConsoleCore.js";
+
+test("registerConsoleCore registers the console action surface alias when action runtime is available", () => {
+  const calls = [];
+  const app = {
+    singleton() {
+      return this;
+    },
+    actionSurfaceSource(sourceName, resolver) {
+      calls.push({
+        sourceName: String(sourceName || ""),
+        resolverType: typeof resolver
+      });
+      return this;
+    }
+  };
+
+  registerConsoleCore(app);
+
+  assert.deepEqual(calls, [
+    {
+      sourceName: "console",
+      resolverType: "function"
+    }
+  ]);
+});
+
+test("registerConsoleCore still works when action runtime has not installed actionSurfaceSource yet", () => {
+  const app = {
+    singleton() {
+      return this;
+    }
+  };
+
+  assert.doesNotThrow(() => registerConsoleCore(app));
+});

package/test/registerServiceRealtimeEvents.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerConsoleSettings } from "../src/server/consoleSettings/registerConsoleSettings.js";
+
+function createAppDouble() {
+  const serviceCalls = [];
+
+  return {
+    serviceCalls,
+    app: {
+      singleton() {
+        return this;
+      },
+      service(token, factory, metadata) {
+        serviceCalls.push({
+          token,
+          factory,
+          metadata
+        });
+        return this;
+      },
+      actions() {
+        return this;
+      }
+    }
+  };
+}
+
+function findServiceCall(serviceCalls, token) {
+  return serviceCalls.find((entry) => entry.token === token) || null;
+}
+
+test("console settings register publishes console.settings.changed", () => {
+  const payload = createAppDouble();
+  registerConsoleSettings(payload.app);
+  const consoleSettings = findServiceCall(payload.serviceCalls, "console.settings.service");
+  assert.equal(consoleSettings?.metadata?.events?.updateSettings?.[0]?.realtime?.event, "console.settings.changed");
+});

package/test/repositoryContracts.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createRepository as createConsoleSettingsRepository } from "../src/server/consoleSettings/consoleSettingsRepository.js";
+
+function createKnexStub() {
+  const knex = Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+
+  return knex;
+}
+
+test("console-core repositories expose withTransaction", async () => {
+  const knex = createKnexStub();
+  const repositories = [
+    createConsoleSettingsRepository(knex)
+  ];
+
+  for (const repository of repositories) {
+    assert.equal(typeof repository.withTransaction, "function");
+    const result = await repository.withTransaction(async (trx) => ({ id: trx.trxId }));
+    assert.deepEqual(result, { id: "trx-1" });
+  }
+});

package/test/settingsFieldRegistriesSingleton.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+async function importWithIdentity(url, identity) {
+  return import(`${url.href}?identity=${identity}`);
+}
+
+test("settings field registries stay shared across module identities", async () => {
+  const consoleModuleUrl = new URL("../src/shared/resources/consoleSettingsFields.js", import.meta.url);
+
+  const consoleA = await importWithIdentity(consoleModuleUrl, "console-a");
+  const consoleB = await importWithIdentity(consoleModuleUrl, "console-b");
+  assert.equal(consoleA.consoleSettingsFields, consoleB.consoleSettingsFields);
+});

package/test-support/registerDefaultSettingsFields.js

@@ -0,0 +1 @@
+import "../templates/packages/main/src/shared/resources/consoleSettingsFields.js";