@jskit-ai/console-core 0.1.1

package/src/shared/resources/consoleSettingsFields.js

@@ -0,0 +1,54 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
+
+const consoleSettingsFields = resolveGlobalArrayRegistry("jskit.console-core.consoleSettingsFields");
+
+function defineField(field = {}) {
+  const key = normalizeText(field.key);
+  if (!key) {
+    throw new TypeError("consoleSettingsFields.defineField requires field.key.");
+  }
+  if (consoleSettingsFields.some((entry) => entry.key === key)) {
+    throw new Error(`consoleSettingsFields.defineField duplicate key: ${key}`);
+  }
+  if (!field.inputSchema || typeof field.inputSchema !== "object") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires inputSchema.`);
+  }
+  if (!field.outputSchema || typeof field.outputSchema !== "object") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires outputSchema.`);
+  }
+  const dbColumn = normalizeText(field.dbColumn);
+  if (!dbColumn) {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires dbColumn.`);
+  }
+  if (typeof field.normalizeInput !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeInput.`);
+  }
+  if (typeof field.normalizeOutput !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeOutput.`);
+  }
+  if (typeof field.resolveDefault !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires resolveDefault.`);
+  }
+
+  consoleSettingsFields.push({
+    key,
+    dbColumn,
+    required: field.required !== false,
+    inputSchema: field.inputSchema,
+    outputSchema: field.outputSchema,
+    normalizeInput: field.normalizeInput,
+    normalizeOutput: field.normalizeOutput,
+    resolveDefault: field.resolveDefault
+  });
+}
+
+function resetConsoleSettingsFields() {
+  consoleSettingsFields.splice(0, consoleSettingsFields.length);
+}
+
+export {
+  defineField,
+  resetConsoleSettingsFields,
+  consoleSettingsFields
+};

package/src/shared/resources/consoleSettingsResource.js

@@ -0,0 +1,119 @@
+import { Type } from "typebox";
+import { createOperationMessages } from "../operationMessages.js";
+import {
+  createCursorListValidator,
+  normalizeObjectInput,
+  normalizeSettingsFieldInput,
+  normalizeSettingsFieldOutput
+} from "@jskit-ai/kernel/shared/validators";
+import { consoleSettingsFields } from "./consoleSettingsFields.js";
+
+function buildCreateSchema() {
+  const properties = {};
+  for (const field of consoleSettingsFields) {
+    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
+  }
+  return Type.Object(properties, { additionalProperties: false });
+}
+
+function buildOutputSchema() {
+  const properties = {};
+  for (const field of consoleSettingsFields) {
+    properties[field.key] = field.outputSchema;
+  }
+  return Type.Object(properties, { additionalProperties: false });
+}
+
+function buildConsoleSettingsRecordSchema() {
+  return Type.Object(
+    {
+      settings: buildOutputSchema()
+    },
+    { additionalProperties: false }
+  );
+}
+
+function buildConsoleSettingsCreateSchema() {
+  return buildCreateSchema();
+}
+
+function buildConsoleSettingsReplaceSchema() {
+  return buildConsoleSettingsCreateSchema();
+}
+
+function buildConsoleSettingsPatchSchema() {
+  return Type.Partial(buildConsoleSettingsCreateSchema(), {
+    additionalProperties: false
+  });
+}
+
+function normalizeConsoleSettingsInput(payload = {}) {
+  return normalizeSettingsFieldInput(payload, consoleSettingsFields);
+}
+
+const consoleSettingsOutputValidator = Object.freeze({
+  get schema() {
+    return buildConsoleSettingsRecordSchema();
+  },
+  normalize(payload = {}) {
+    const source = normalizeObjectInput(payload);
+    const settingsSource = normalizeObjectInput(source.settings);
+
+    return {
+      settings: normalizeSettingsFieldOutput(settingsSource, consoleSettingsFields)
+    };
+  }
+});
+
+const CONSOLE_SETTINGS_OPERATION_MESSAGES = createOperationMessages();
+
+const consoleSettingsResource = Object.freeze({
+  resource: "consoleSettings",
+  operations: Object.freeze({
+    view: Object.freeze({
+      method: "GET",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    list: Object.freeze({
+      method: "GET",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      outputValidator: createCursorListValidator(consoleSettingsOutputValidator)
+    }),
+    create: Object.freeze({
+      method: "POST",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsCreateSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    replace: Object.freeze({
+      method: "PUT",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsReplaceSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    patch: Object.freeze({
+      method: "PATCH",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsPatchSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    })
+  })
+});
+
+export { consoleSettingsResource };

package/src/shared/resources/resolveGlobalArrayRegistry.js

@@ -0,0 +1,6 @@
+function resolveGlobalArrayRegistry(symbolKey) {
+  globalThis[symbolKey] = Array.isArray(globalThis[symbolKey]) ? globalThis[symbolKey] : [];
+  return globalThis[symbolKey];
+}
+
+export { resolveGlobalArrayRegistry };

package/templates/migrations/console_core_generic_initial.cjs

@@ -0,0 +1,27 @@
+/**
+ * @param {import('knex').Knex} knex
+ */
+exports.up = async function up(knex) {
+  const hasConsoleSettingsTable = await knex.schema.hasTable("console_settings");
+  if (!hasConsoleSettingsTable) {
+    await knex.schema.createTable("console_settings", (table) => {
+      table.bigInteger("id").primary();
+      table.bigInteger("owner_user_id").unsigned().nullable().references("id").inTable("users").onDelete("SET NULL");
+      table.timestamp("created_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
+      table.timestamp("updated_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
+    });
+
+    await knex("console_settings").insert({
+      id: 1,
+      created_at: knex.fn.now(),
+      updated_at: knex.fn.now()
+    });
+  }
+};
+
+/**
+ * @param {import('knex').Knex} knex
+ */
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists("console_settings");
+};

package/templates/packages/main/src/shared/resources/consoleSettingsFields.js

@@ -0,0 +1,11 @@
+// @jskit-contract console.settings-fields.v1
+// Append-only settings field registrations for console settings.
+
+import {
+  defineField,
+  resetConsoleSettingsFields
+} from "@jskit-ai/console-core/shared/resources/consoleSettingsFields";
+
+resetConsoleSettingsFields();
+
+void defineField;

package/test/bootstrapPayloadIntegration.test.js

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createContainer } from "../../kernel/server/container/index.js";
+import { resolveBootstrapPayload } from "../../kernel/server/registries/bootstrapPayloadContributorRegistry.js";
+import { registerUsersBootstrap } from "../../users-core/src/server/registerUsersBootstrap.js";
+import { registerConsoleBootstrap } from "../src/server/registerConsoleBootstrap.js";
+
+function createAuthenticatedProfile(overrides = {}) {
+  return {
+    id: "12",
+    authProvider: "local",
+    authProviderUserSid: "user-12",
+    username: "consoleowner",
+    displayName: "Console Owner",
+    email: "owner@example.com",
+    ...overrides
+  };
+}
+
+test("bootstrap payload preserves consoleowner for authenticated users after users bootstrap runs", async () => {
+  const profile = createAuthenticatedProfile();
+  const ownerSeeds = [];
+  const app = createContainer();
+
+  app.instance("usersRepository", {
+    async findById(userId) {
+      return String(userId || "") === profile.id ? profile : null;
+    }
+  });
+  app.instance("userSettingsRepository", {
+    async ensureForUserId() {
+      return {};
+    }
+  });
+  app.instance("users.tenancy.profile", {
+    mode: "none",
+    workspace: {
+      enabled: false,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: "none"
+    }
+  });
+  app.instance("authService", {
+    getOAuthProviderCatalog() {
+      return {
+        providers: [],
+        defaultProvider: null
+      };
+    },
+    writeSessionCookies() {},
+    clearSessionCookies() {}
+  });
+  app.instance("consoleService", {
+    async ensureInitialConsoleMember(userId) {
+      ownerSeeds.push(String(userId || ""));
+      return String(userId || "");
+    }
+  });
+
+  registerConsoleBootstrap(app);
+  registerUsersBootstrap(app);
+
+  const payload = await resolveBootstrapPayload(app, {
+    request: {
+      async executeAction({ actionId }) {
+        assert.equal(actionId, "auth.session.read");
+        return {
+          authenticated: true,
+          profile,
+          session: {
+            csrfToken: "csrf-1"
+          }
+        };
+      }
+    },
+    reply: {}
+  });
+
+  assert.deepEqual(ownerSeeds, ["12"]);
+  assert.equal(payload.session.authenticated, true);
+  assert.equal(payload.session.userId, "12");
+  assert.deepEqual(payload.surfaceAccess, {
+    consoleowner: true
+  });
+});

package/test/consoleActionSurfaces.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  resolveConsoleSurfaceIdsFromAppConfig
+} from "../src/server/support/consoleActionSurfaces.js";
+
+test("resolveConsoleSurfaceIdsFromAppConfig resolves all enabled console-owner surfaces", () => {
+  const surfaceIds = resolveConsoleSurfaceIdsFromAppConfig({
+    surfaceDefinitions: {
+      home: { id: "home", enabled: true, requiresWorkspace: false, accessPolicyId: "public" },
+      console: { id: "console", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
+      opsConsole: { id: "opsConsole", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
+      app: { id: "app", enabled: true, requiresWorkspace: true, accessPolicyId: "workspace_member" },
+      disabledConsole: {
+        id: "disabledConsole",
+        enabled: false,
+        requiresWorkspace: false,
+        accessPolicyId: "console_owner"
+      }
+    }
+  });
+
+  assert.deepEqual(surfaceIds, ["console", "opsconsole"]);
+});

package/test/consoleBootstrapContributor.test.js

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createConsoleBootstrapContributor } from "../src/server/consoleBootstrapContributor.js";
+
+test("console bootstrap contributor seeds the initial console owner into the existing bootstrap payload", async () => {
+  const ownerSeeds = [];
+  const contributor = createConsoleBootstrapContributor({
+    consoleService: {
+      async ensureInitialConsoleMember(userId) {
+        ownerSeeds.push(String(userId || ""));
+        return String(userId || "");
+      }
+    }
+  });
+
+  assert.equal(contributor.order, 300);
+  const contribution = await contributor.contribute({
+    payload: {
+      session: {
+        authenticated: true,
+        userId: "12"
+      },
+      surfaceAccess: {
+        existing: true
+      }
+    }
+  });
+
+  assert.deepEqual(ownerSeeds, ["12"]);
+  assert.deepEqual(contribution, {
+    surfaceAccess: {
+      existing: true,
+      consoleowner: true
+    }
+  });
+});
+
+test("console bootstrap contributor exposes a false consoleowner flag for anonymous bootstrap", async () => {
+  const contributor = createConsoleBootstrapContributor({
+    consoleService: {
+      async ensureInitialConsoleMember() {
+        throw new Error("should not be called for anonymous payload");
+      }
+    }
+  });
+
+  const contribution = await contributor.contribute({
+    payload: {
+      session: {
+        authenticated: false
+      },
+      surfaceAccess: {
+        existing: true
+      }
+    }
+  });
+
+  assert.deepEqual(contribution, {
+    surfaceAccess: {
+      existing: true,
+      consoleowner: false
+    }
+  });
+});

package/test/consoleRouteRequestInputValidator.test.js

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ConsoleCoreServiceProvider } from "../src/server/ConsoleCoreServiceProvider.js";
+
+function createReplyDouble() {
+  return {
+    statusCode: 200,
+    payload: null,
+    redirectedTo: "",
+    code(value) {
+      this.statusCode = value;
+      return this;
+    },
+    send(value) {
+      this.payload = value;
+      return this;
+    },
+    redirect(value) {
+      this.redirectedTo = String(value || "");
+      return this;
+    }
+  };
+}
+
+function findRoute(routes, { method, path }) {
+  return routes.find((route) => route.method === method && route.path === path) || null;
+}
+
+async function registerRoutes({
+  consoleService = {}
+} = {}) {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        ...route,
+        method,
+        path,
+        handler
+      });
+    }
+  };
+
+  const bindings = new Map([
+    ["jskit.http.router", router],
+    ["actionExecutor", {}]
+  ]);
+
+  bindings.set("consoleService", consoleService);
+
+  const app = {
+    has(token) {
+      return bindings.has(token);
+    },
+    make(token) {
+      if (!bindings.has(token)) {
+        throw new Error(`Missing test binding for token: ${String(token)}`);
+      }
+      return bindings.get(token);
+    }
+  };
+
+  const provider = new ConsoleCoreServiceProvider();
+  await provider.boot(app);
+
+  return registeredRoutes;
+}
+
+function createActionRequest({ input = {}, executeAction, file = null }) {
+  return {
+    input,
+    executeAction,
+    file,
+    user: {
+      id: 42
+    }
+  };
+}
+
+test("console-core boot mounts console routes", async () => {
+  const routes = await registerRoutes();
+
+  assert.equal(findRoute(routes, { method: "GET", path: "/api/console/settings" })?.path, "/api/console/settings");
+  assert.equal(findRoute(routes, { method: "PATCH", path: "/api/console/settings" })?.path, "/api/console/settings");
+});
+
+test("console settings route handlers use request.input payloads", async () => {
+  const routes = await registerRoutes();
+  const calls = [];
+  const executeAction = async (payload) => {
+    calls.push(payload);
+    return {
+      settings: {}
+    };
+  };
+
+  await findRoute(routes, { method: "GET", path: "/api/console/settings" }).handler(
+    createActionRequest({ executeAction }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, { method: "PATCH", path: "/api/console/settings" }).handler(
+    createActionRequest({
+      input: {
+        body: {}
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  assert.equal(calls[0].actionId, "console.settings.read");
+  assert.deepEqual(calls[1], {
+    actionId: "console.settings.update",
+    input: {
+      payload: {}
+    }
+  });
+});

package/test/consoleRouteResources.test.js

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
+import "../test-support/registerDefaultSettingsFields.js";
+import { consoleSettingsResource } from "../src/shared/resources/consoleSettingsResource.js";
+
+function assertResourceShape(resource, label) {
+  assert.ok(resource, `${label} resource must exist.`);
+  assert.equal(typeof resource, "object", `${label} resource must be an object.`);
+  assert.equal(typeof resource.resource, "string", `${label}.resource must be a string.`);
+
+  for (const operationName of ["view", "list", "create", "replace", "patch"]) {
+    const operation = resource.operations?.[operationName];
+    assert.equal(typeof operation, "object", `${label}.operations.${operationName} must exist.`);
+    assert.equal(typeof operation.method, "string", `${label}.operations.${operationName}.method must exist.`);
+    const resolvedMessages =
+      operation?.messages && typeof operation.messages === "object"
+        ? operation.messages
+        : resource?.messages || resource?.operationMessages;
+    assert.equal(
+      typeof resolvedMessages,
+      "object",
+      `${label}.operations.${operationName} must resolve messages from operation.messages or resource.messages.`
+    );
+    assert.equal(
+      typeof operation.outputValidator?.schema,
+      "object",
+      `${label}.operations.${operationName} payload schema is required.`
+    );
+  }
+
+  assert.equal(typeof resource.operations.create.bodyValidator?.schema, "object", `${label}.operations.create.bodyValidator.schema is required.`);
+  assert.equal(typeof resource.operations.replace.bodyValidator?.schema, "object", `${label}.operations.replace.bodyValidator.schema is required.`);
+  assert.equal(typeof resource.operations.patch.bodyValidator?.schema, "object", `${label}.operations.patch.bodyValidator.schema is required.`);
+
+  const requiredMetadata = deriveResourceRequiredMetadata(resource);
+  assert.ok(Array.isArray(requiredMetadata.create), `${label}.derivedRequired.create must be an array.`);
+  assert.ok(Array.isArray(requiredMetadata.replace), `${label}.derivedRequired.replace must be an array.`);
+  assert.ok(Array.isArray(requiredMetadata.patch), `${label}.derivedRequired.patch must be an array.`);
+}
+
+test("console settings resources expose canonical validators", () => {
+  assertResourceShape(consoleSettingsResource, "consoleSettings");
+});
+
+test("console settings operations expose canonical validators", () => {
+  for (const operationName of ["view", "list", "create", "replace", "patch"]) {
+    const operation = consoleSettingsResource.operations?.[operationName];
+    assert.equal(typeof operation?.method, "string", `${operationName}.method must exist.`);
+    assert.equal(typeof operation?.outputValidator?.schema, "object", `${operationName}.outputValidator.schema must exist.`);
+    if (operation?.bodyValidator) {
+      assert.equal(typeof operation.bodyValidator.schema, "object", `${operationName}.bodyValidator.schema must exist.`);
+    }
+  }
+});
+
+test("console-core no longer uses a legacy workspace schema helper path", () => {
+  const testFilePath = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(testFilePath), "..");
+  const legacyWorkspaceRoutesFile = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
+  assert.equal(existsSync(legacyWorkspaceRoutesFile), false, "workspaceRoutes.js must not exist.");
+});
+
+test("console-core route validators do not live under a legacy shared/schema directory", () => {
+  const testFilePath = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(testFilePath), "..");
+  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+});

package/test/consoleService.test.js

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createService } from "../src/server/consoleSettings/consoleService.js";
+
+function createFixture(initialOwnerUserId = null) {
+  const state = {
+    ownerUserId: initialOwnerUserId
+  };
+
+  const service = createService({
+    consoleSettingsRepository: {
+      async ensureOwnerUserId(userId) {
+        const normalizedUserId = String(userId || "");
+        if (!state.ownerUserId) {
+          state.ownerUserId = normalizedUserId;
+        }
+        return state.ownerUserId;
+      }
+    }
+  });
+
+  return { service, state };
+}
+
+test("consoleService seeds the first authenticated user as console owner", async () => {
+  const { service, state } = createFixture();
+
+  const firstOwner = await service.ensureInitialConsoleMember("7");
+  const secondAttempt = await service.ensureInitialConsoleMember("9");
+
+  assert.equal(firstOwner, "7");
+  assert.equal(secondAttempt, "7");
+  assert.equal(state.ownerUserId, "7");
+});
+
+test("consoleService.requireConsoleOwner denies authenticated non-owners", async () => {
+  const { service } = createFixture("7");
+
+  await assert.rejects(
+    () =>
+      service.requireConsoleOwner({
+        actor: {
+          id: "9"
+        }
+      }),
+    (error) => error?.status === 403
+  );
+});
+
+test("consoleService.requireConsoleOwner requires authentication", async () => {
+  const { service } = createFixture("7");
+
+  await assert.rejects(
+    () => service.requireConsoleOwner({}),
+    (error) => error?.status === 401
+  );
+});