@jskit-ai/users-core 0.1.46 → 0.1.48

package/test/workspaceActionSurfaces.test.js

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   materializeWorkspaceActionSurfacesFromAppConfig,
-  resolveConsoleSurfaceIdsFromAppConfig,
   resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig
 } from "../src/server/support/workspaceActionSurfaces.js";
 
@@ -23,7 +22,7 @@ test("materializeWorkspaceActionSurfacesFromAppConfig resolves workspace surface
       surfaceDefinitions: {
         app: { id: "app", enabled: true, requiresWorkspace: true },
         admin: { id: "admin", enabled: true, requiresWorkspace: true },
-        console: { id: "console", enabled: true, requiresWorkspace: false }
+        ops: { id: "ops", enabled: true, requiresWorkspace: false }
       }
     }
   });
@@ -52,7 +51,7 @@ test("materializeWorkspaceActionSurfacesFromAppConfig drops workspace actions wh
     appConfig: {
       surfaceDefinitions: {
         app: { id: "app", enabled: true, requiresWorkspace: false },
-        console: { id: "console", enabled: true, requiresWorkspace: false }
+        ops: { id: "ops", enabled: true, requiresWorkspace: false }
       }
     }
   });
@@ -78,28 +77,9 @@ test("resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig falls back to app defau
     surfaceDefaultId: "home",
     surfaceDefinitions: {
       home: { id: "home", enabled: true, requiresWorkspace: false },
-      console: { id: "console", enabled: true, requiresWorkspace: false }
+      ops: { id: "ops", enabled: true, requiresWorkspace: false }
     }
   });
 
   assert.equal(surfaceId, "home");
 });
-
-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-support/registerDefaultSettingsFields.js

@@ -1,3 +1,2 @@
 import "../../workspaces-core/templates/packages/main/src/shared/resources/workspaceSettingsFields.js";
-import "../templates/packages/main/src/shared/resources/consoleSettingsFields.js";
 import "../templates/packages/main/src/shared/resources/userSettingsFields.js";

package/src/server/consoleSettings/bootConsoleSettingsRoutes.js

@@ -1,63 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { consoleSettingsResource } from "../../shared/resources/consoleSettingsResource.js";
-
-function bootConsoleSettingsRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootConsoleSettingsRoutes requires application make().");
-  }
-
-  const router = app.make("jskit.http.router");
-
-  router.register(
-    "GET",
-    "/api/console/settings",
-    {
-      auth: "required",
-      surface: "console",
-      meta: {
-        tags: ["console", "settings"],
-        summary: "Get console settings"
-      },
-      responseValidators: withStandardErrorResponses({
-        200: consoleSettingsResource.operations.view.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "console.settings.read"
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    "/api/console/settings",
-    {
-      auth: "required",
-      surface: "console",
-      meta: {
-        tags: ["console", "settings"],
-        summary: "Update console settings"
-      },
-      bodyValidator: consoleSettingsResource.operations.replace.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: consoleSettingsResource.operations.view.outputValidator
-        },
-        { includeValidation400: true }
-      )
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "console.settings.update",
-        input: {
-          payload: request.input.body
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { bootConsoleSettingsRoutes };

package/src/server/consoleSettings/consoleService.js

@@ -1,36 +0,0 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-
-function createService({ consoleSettingsRepository } = {}) {
-  if (!consoleSettingsRepository || typeof consoleSettingsRepository.ensureOwnerUserId !== "function") {
-    throw new Error("consoleService requires consoleSettingsRepository.ensureOwnerUserId().");
-  }
-
-  async function ensureInitialConsoleMember(userId, options = {}) {
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedUserId) {
-      throw new AppError(400, "Invalid console user.");
-    }
-
-    return consoleSettingsRepository.ensureOwnerUserId(normalizedUserId, options);
-  }
-
-  async function requireConsoleOwner(context = {}, options = {}) {
-    const actorUserId = normalizeRecordId(context?.actor?.id, { fallback: null });
-    if (!actorUserId) {
-      throw new AppError(401, "Authentication required.");
-    }
-
-    const ownerUserId = await ensureInitialConsoleMember(actorUserId, options);
-    if (actorUserId !== ownerUserId) {
-      throw new AppError(403, "Forbidden.");
-    }
-  }
-
-  return Object.freeze({
-    ensureInitialConsoleMember,
-    requireConsoleOwner
-  });
-}
-
-export { createService };

package/src/server/consoleSettings/consoleSettingsActions.js

@@ -1,55 +0,0 @@
-import {
-  EMPTY_INPUT_VALIDATOR
-} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
-import { consoleSettingsResource } from "../../shared/resources/consoleSettingsResource.js";
-
-const consoleSettingsActions = Object.freeze([
-  {
-    id: "console.settings.read",
-    version: 1,
-    kind: "query",
-    channels: ["api", "automation", "internal"],
-    surfacesFrom: "console",
-    permission: {
-      require: "authenticated"
-    },
-    inputValidator: EMPTY_INPUT_VALIDATOR,
-    outputValidator: consoleSettingsResource.operations.view.outputValidator,
-    idempotency: "none",
-    audit: {
-      actionName: "console.settings.read"
-    },
-    observability: {},
-    async execute(_input, context, deps) {
-      return deps.consoleSettingsService.getSettings({
-        context
-      });
-    }
-  },
-  {
-    id: "console.settings.update",
-    version: 1,
-    kind: "command",
-    channels: ["api", "automation", "internal"],
-    surfacesFrom: "console",
-    permission: {
-      require: "authenticated"
-    },
-    inputValidator: {
-      payload: consoleSettingsResource.operations.replace.bodyValidator
-    },
-    outputValidator: consoleSettingsResource.operations.replace.outputValidator,
-    idempotency: "optional",
-    audit: {
-      actionName: "console.settings.update"
-    },
-    observability: {},
-    async execute(input, context, deps) {
-      return deps.consoleSettingsService.updateSettings(input.payload, {
-        context
-      });
-    }
-  }
-]);
-
-export { consoleSettingsActions };

package/src/server/consoleSettings/consoleSettingsRepository.js

@@ -1,115 +0,0 @@
-import {
-  normalizeDbRecordId,
-  normalizeRecordId,
-  nowDb,
-  toIsoString,
-  createWithTransaction
-} from "../common/repositories/repositoryUtils.js";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { consoleSettingsFields } from "../../shared/resources/consoleSettingsFields.js";
-
-function mapSettings(row = {}) {
-  const settings = {};
-  for (const field of consoleSettingsFields) {
-    const rawValue = Object.hasOwn(row, field.dbColumn)
-      ? row[field.dbColumn]
-      : field.resolveDefault({
-          settings: row
-        });
-    settings[field.key] = field.normalizeOutput(rawValue, {
-      settings: row
-    });
-  }
-  return settings;
-}
-
-function mapSingletonRow(row) {
-  if (!row) {
-    throw new Error("console_settings singleton row is missing.");
-  }
-
-  const ownerUserId = normalizeDbRecordId(row.owner_user_id, { fallback: null });
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "1" }),
-    ownerUserId,
-    settings: mapSettings(row),
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at)
-  };
-}
-
-function createRepository(knex) {
-  if (typeof knex !== "function") {
-    throw new TypeError("consoleSettingsRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
-
-  async function readSingleton(client) {
-    return client("console_settings").where({ id: 1 }).first();
-  }
-
-  async function getSingleton(options = {}) {
-    const client = options?.trx || knex;
-    return mapSingletonRow(await readSingleton(client));
-  }
-
-  async function ensureOwnerUserId(userId, options = {}) {
-    const client = options?.trx || knex;
-    const candidateOwnerUserId = normalizeRecordId(userId, { fallback: null });
-    if (!candidateOwnerUserId) {
-      throw new TypeError("consoleSettingsRepository.ensureOwnerUserId requires a positive user id.");
-    }
-
-    const current = mapSingletonRow(await readSingleton(client));
-    if (current.ownerUserId) {
-      return current.ownerUserId;
-    }
-
-    await client("console_settings")
-      .where({ id: 1 })
-      .whereNull("owner_user_id")
-      .update({
-        owner_user_id: candidateOwnerUserId,
-        updated_at: nowDb()
-      });
-
-    const reloaded = mapSingletonRow(await readSingleton(client));
-    if (!reloaded.ownerUserId) {
-      throw new Error("console_settings owner_user_id could not be resolved.");
-    }
-
-    return reloaded.ownerUserId;
-  }
-
-  async function updateSingleton(patch, options = {}) {
-    const client = options?.trx || knex;
-    const source = normalizeObjectInput(patch);
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-    for (const field of consoleSettingsFields) {
-      if (!Object.hasOwn(source, field.key)) {
-        continue;
-      }
-      dbPatch[field.dbColumn] = field.normalizeInput(source[field.key], {
-        payload: source
-      });
-    }
-
-    await client("console_settings")
-      .where({ id: 1 })
-      .update(dbPatch);
-
-    return getSingleton({ trx: client });
-  }
-
-  return Object.freeze({
-    withTransaction,
-    getSingleton,
-    ensureOwnerUserId,
-    updateSingleton
-  });
-}
-
-export { createRepository };

package/src/server/consoleSettings/consoleSettingsService.js

@@ -1,40 +0,0 @@
-function buildSettingsResponse(record = {}) {
-  return {
-    settings: {
-      ...(record?.settings && typeof record.settings === "object" ? record.settings : {})
-    }
-  };
-}
-
-function createService({ consoleSettingsRepository, consoleService } = {}) {
-  if (!consoleSettingsRepository || typeof consoleSettingsRepository.getSingleton !== "function") {
-    throw new Error("consoleSettingsService requires consoleSettingsRepository.getSingleton().");
-  }
-  if (!consoleSettingsRepository || typeof consoleSettingsRepository.updateSingleton !== "function") {
-    throw new Error("consoleSettingsService requires consoleSettingsRepository.updateSingleton().");
-  }
-  if (!consoleService || typeof consoleService.requireConsoleOwner !== "function") {
-    throw new Error("consoleSettingsService requires consoleService.requireConsoleOwner().");
-  }
-
-  async function getSettings(options = {}) {
-    await consoleService.requireConsoleOwner(options?.context, options);
-    const settings = await consoleSettingsRepository.getSingleton();
-
-    return buildSettingsResponse(settings);
-  }
-
-  async function updateSettings(input = {}, options = {}) {
-    await consoleService.requireConsoleOwner(options?.context, options);
-    const settings = await consoleSettingsRepository.updateSingleton(input);
-
-    return buildSettingsResponse(settings);
-  }
-
-  return Object.freeze({
-    getSettings,
-    updateSettings
-  });
-}
-
-export { createService };

package/src/server/consoleSettings/registerConsoleSettings.js

@@ -1,56 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { createService as createConsoleSettingsService } from "./consoleSettingsService.js";
-import { createService as createConsoleService } from "./consoleService.js";
-import { consoleSettingsActions } from "./consoleSettingsActions.js";
-
-function registerConsoleSettings(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerConsoleSettings requires application singleton()/service()/actions().");
-  }
-
-  const hasConsoleService = typeof app.has === "function" ? app.has("consoleService") : false;
-  if (!hasConsoleService) {
-    app.singleton("consoleService", (scope) =>
-      createConsoleService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository")
-      })
-    );
-  }
-
-  app.service(
-    "users.console.settings.service",
-    (scope) =>
-      createConsoleSettingsService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository"),
-        consoleService: scope.make("consoleService")
-      }),
-    {
-      events: Object.freeze({
-        updateSettings: Object.freeze([
-          Object.freeze({
-            type: "entity.changed",
-            source: "console",
-            entity: "settings",
-            operation: "updated",
-            entityId: 1,
-            realtime: Object.freeze({
-              event: "console.settings.changed",
-              audience: "all_users"
-            })
-          })
-        ])
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(consoleSettingsActions, {
-      domain: "console",
-      dependencies: {
-        consoleSettingsService: "users.console.settings.service"
-      }
-    })
-  );
-}
-
-export { registerConsoleSettings };

package/src/shared/resources/consoleSettingsFields.js

@@ -1,54 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
-
-const consoleSettingsFields = resolveGlobalArrayRegistry("jskit.users-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

@@ -1,119 +0,0 @@
-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/templates/migrations/users_core_console_owner.cjs

@@ -1,37 +0,0 @@
-/**
- * @param {import('knex').Knex} knex
- */
-exports.up = async function up(knex) {
-  const hasConsoleSettingsTable = await knex.schema.hasTable("console_settings");
-  if (!hasConsoleSettingsTable) {
-    return;
-  }
-
-  const hasOwnerUserId = await knex.schema.hasColumn("console_settings", "owner_user_id");
-  if (hasOwnerUserId) {
-    return;
-  }
-
-  await knex.schema.alterTable("console_settings", (table) => {
-    table.bigInteger("owner_user_id").unsigned().nullable();
-  });
-};
-
-/**
- * @param {import('knex').Knex} knex
- */
-exports.down = async function down(knex) {
-  const hasConsoleSettingsTable = await knex.schema.hasTable("console_settings");
-  if (!hasConsoleSettingsTable) {
-    return;
-  }
-
-  const hasOwnerUserId = await knex.schema.hasColumn("console_settings", "owner_user_id");
-  if (!hasOwnerUserId) {
-    return;
-  }
-
-  await knex.schema.alterTable("console_settings", (table) => {
-    table.dropColumn("owner_user_id");
-  });
-};

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

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