@jskit-ai/users-core 0.1.28 → 0.1.29

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-core",
-  version: "0.1.28",
+  version: "0.1.29",
   kind: "runtime",
   description: "Users/workspace domain runtime plus HTTP routes for workspace, account, and console features.",
   dependsOn: [
@@ -196,10 +196,10 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.18",
-        "@jskit-ai/database-runtime": "0.1.19",
-        "@jskit-ai/http-runtime": "0.1.18",
-        "@jskit-ai/kernel": "0.1.19",
+        "@jskit-ai/auth-core": "0.1.19",
+        "@jskit-ai/database-runtime": "0.1.20",
+        "@jskit-ai/http-runtime": "0.1.19",
+        "@jskit-ai/kernel": "0.1.20",
         "@fastify/multipart": "^9.4.0",
         "@fastify/type-provider-typebox": "^6.1.0",
         "typebox": "^1.0.81"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-core",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -24,10 +24,10 @@
     "./shared/resources/consoleSettingsFields": "./src/shared/resources/consoleSettingsFields.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.18",
-    "@jskit-ai/database-runtime": "0.1.19",
-    "@jskit-ai/http-runtime": "0.1.18",
-    "@jskit-ai/kernel": "0.1.19",
+    "@jskit-ai/auth-core": "0.1.19",
+    "@jskit-ai/database-runtime": "0.1.20",
+    "@jskit-ai/http-runtime": "0.1.19",
+    "@jskit-ai/kernel": "0.1.20",
     "@fastify/multipart": "^9.4.0",
     "@fastify/type-provider-typebox": "^6.1.0",
     "typebox": "^1.0.81"

package/src/server/common/contributors/workspaceActionContextContributor.js

@@ -3,7 +3,7 @@ import {
   requireServiceMethod
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import {
-  normalizeScopedRouteVisibility,
+  checkRouteVisibility,
   USERS_ROUTE_VISIBILITY_PUBLIC,
   USERS_ROUTE_VISIBILITY_WORKSPACE,
   USERS_ROUTE_VISIBILITY_WORKSPACE_USER
@@ -41,9 +41,11 @@ function createWorkspaceActionContextContributor({ workspaceService } = {}) {
 
       const actionName = String(actionId || "").trim();
       const hasLegacyWorkspaceActionId = WORKSPACE_CONTEXT_ACTION_IDS.includes(actionName);
-      const routeVisibility = normalizeScopedRouteVisibility(request?.routeOptions?.config?.visibility, {
-        fallback: USERS_ROUTE_VISIBILITY_PUBLIC
-      });
+      const routeVisibilityInput =
+        request && request.routeOptions && request.routeOptions.config
+          ? request.routeOptions.config.visibility
+          : USERS_ROUTE_VISIBILITY_PUBLIC;
+      const routeVisibility = checkRouteVisibility(routeVisibilityInput);
       const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
       if (!hasLegacyWorkspaceActionId && !hasWorkspaceRouteVisibility) {
         return {};

package/src/server/common/services/authProfileSyncService.js

@@ -53,13 +53,16 @@ function requireSynchronizedProfile(profile) {
   throw new Error("Profile synchronization failed.");
 }
 
-function createService({ userProfilesRepository, workspaceProvisioningService = null } = {}) {
+function createService({ userProfilesRepository, workspaceProvisioningService = null, userSettingsRepository = null } = {}) {
   if (!userProfilesRepository || typeof userProfilesRepository.findByIdentity !== "function") {
     throw new Error("authProfileSyncService requires userProfilesRepository.findByIdentity().");
   }
   if (typeof userProfilesRepository.upsert !== "function") {
     throw new Error("authProfileSyncService requires userProfilesRepository.upsert().");
   }
+  if (!userSettingsRepository || typeof userSettingsRepository.ensureForUserId !== "function") {
+    throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
+  }
 
   async function findByIdentity(identityLike, options = {}) {
     const normalized = buildNormalizedIdentityKey(identityLike);
@@ -93,11 +96,14 @@ function createService({ userProfilesRepository, workspaceProvisioningService =
       const operationOptions = trx ? { ...options, trx } : options;
       const existing = await findByIdentity(normalized, operationOptions);
       if (!profileNeedsUpdate(existing, normalized)) {
-        return requireSynchronizedProfile(existing);
+        const synchronizedProfile = requireSynchronizedProfile(existing);
+        await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
+        return synchronizedProfile;
       }
 
       const upserted = await upsertByIdentity(normalized, operationOptions);
       const synchronizedProfile = requireSynchronizedProfile(upserted);
+      await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
       if (
         !existing &&
         workspaceProvisioningService &&

package/src/server/registerWorkspaceCore.js

@@ -30,6 +30,7 @@ function registerWorkspaceCore(app) {
   app.singleton("users.profile.sync.service", (scope) => {
     return createAuthProfileSyncService({
       userProfilesRepository: scope.make("userProfilesRepository"),
+      userSettingsRepository: scope.make("userSettingsRepository"),
       workspaceProvisioningService: scope.make("users.workspace.service")
     });
   });

package/src/shared/support/usersVisibility.js

@@ -1,4 +1,4 @@
-import { normalizeRouteVisibilityToken } from "@jskit-ai/kernel/shared/support/visibility";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
 const USERS_ROUTE_VISIBILITY_PUBLIC = "public";
 const USERS_ROUTE_VISIBILITY_USER = "user";
@@ -13,23 +13,20 @@ const USERS_ROUTE_VISIBILITY_LEVELS = Object.freeze([
 ]);
 const USERS_ROUTE_VISIBILITY_LEVEL_SET = new Set(USERS_ROUTE_VISIBILITY_LEVELS);
 
-function normalizeScopedRouteVisibility(value, { fallback = USERS_ROUTE_VISIBILITY_PUBLIC } = {}) {
-  const normalized = normalizeRouteVisibilityToken(value, { fallback: USERS_ROUTE_VISIBILITY_PUBLIC });
+function checkRouteVisibility(value, { context = "checkRouteVisibility" } = {}) {
+  const normalized = normalizeText(value).toLowerCase();
   if (USERS_ROUTE_VISIBILITY_LEVEL_SET.has(normalized)) {
     return normalized;
   }
 
-  const normalizedFallback = normalizeRouteVisibilityToken(fallback, { fallback: USERS_ROUTE_VISIBILITY_PUBLIC });
-  if (USERS_ROUTE_VISIBILITY_LEVEL_SET.has(normalizedFallback)) {
-    return normalizedFallback;
-  }
-
-  return USERS_ROUTE_VISIBILITY_PUBLIC;
+  throw new TypeError(
+    `${context} must be one of: ${USERS_ROUTE_VISIBILITY_LEVELS.join(", ")}.`
+  );
 }
 
 function isWorkspaceVisibility(visibility = "") {
-  const normalized = normalizeScopedRouteVisibility(visibility, {
-    fallback: USERS_ROUTE_VISIBILITY_PUBLIC
+  const normalized = checkRouteVisibility(visibility, {
+    context: "isWorkspaceVisibility visibility"
   });
   return normalized === USERS_ROUTE_VISIBILITY_WORKSPACE || normalized === USERS_ROUTE_VISIBILITY_WORKSPACE_USER;
 }
@@ -40,6 +37,6 @@ export {
   USERS_ROUTE_VISIBILITY_WORKSPACE,
   USERS_ROUTE_VISIBILITY_WORKSPACE_USER,
   USERS_ROUTE_VISIBILITY_LEVELS,
-  normalizeScopedRouteVisibility,
+  checkRouteVisibility,
   isWorkspaceVisibility
 };

package/test/authProfileSyncService.test.js

@@ -27,6 +27,12 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
         return work(transaction);
       }
     },
+    userSettingsRepository: {
+      async ensureForUserId(userId, options = {}) {
+        calls.push({ step: "ensureUserSettings", userId: Number(userId), trx: options.trx || null });
+        return { userId: Number(userId) };
+      }
+    },
     workspaceProvisioningService: {
       async provisionWorkspaceForNewUser(_profile, options = {}) {
         calls.push({ step: "provision", trx: options.trx || null });
@@ -45,10 +51,12 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
   assert.equal(calls[0].step, "withTransaction");
   assert.equal(calls[1].step, "find");
   assert.equal(calls[2].step, "upsert");
-  assert.equal(calls[3].step, "provision");
+  assert.equal(calls[3].step, "ensureUserSettings");
+  assert.equal(calls[4].step, "provision");
   assert.equal(calls[1].trx, transaction);
   assert.equal(calls[2].trx, transaction);
   assert.equal(calls[3].trx, transaction);
+  assert.equal(calls[4].trx, transaction);
 });
 
 test("authProfileSyncService.syncIdentityProfile skips write path when profile is unchanged", async () => {
@@ -74,6 +82,11 @@ test("authProfileSyncService.syncIdentityProfile skips write path when profile i
         return work({ trxId: "tx-2" });
       }
     },
+    userSettingsRepository: {
+      async ensureForUserId() {
+        return { userId: 7 };
+      }
+    },
     workspaceProvisioningService: {
       async provisionWorkspaceForNewUser() {
         provisionCalls += 1;
@@ -104,6 +117,11 @@ test("authProfileSyncService.findByIdentity normalizes provider identity input",
       async upsert() {
         return null;
       }
+    },
+    userSettingsRepository: {
+      async ensureForUserId() {
+        return { userId: 1 };
+      }
     }
   });
 

package/test/usersVisibility.test.js

@@ -2,16 +2,21 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   isWorkspaceVisibility,
-  normalizeScopedRouteVisibility
+  checkRouteVisibility
 } from "../src/shared/support/usersVisibility.js";
 
-test("normalizeScopedRouteVisibility normalizes users visibility levels", () => {
-  assert.equal(normalizeScopedRouteVisibility("WORKSPACE"), "workspace");
-  assert.equal(normalizeScopedRouteVisibility("workspace_user"), "workspace_user");
-  assert.equal(normalizeScopedRouteVisibility("user"), "user");
-  assert.equal(normalizeScopedRouteVisibility(""), "public");
-  assert.equal(normalizeScopedRouteVisibility("unknown"), "public");
-  assert.equal(normalizeScopedRouteVisibility("unknown", { fallback: "workspace" }), "workspace");
+test("checkRouteVisibility normalizes valid users visibility levels and throws on invalid input", () => {
+  assert.equal(checkRouteVisibility("WORKSPACE"), "workspace");
+  assert.equal(checkRouteVisibility("workspace_user"), "workspace_user");
+  assert.equal(checkRouteVisibility("user"), "user");
+  assert.throws(
+    () => checkRouteVisibility(""),
+    /must be one of/
+  );
+  assert.throws(
+    () => checkRouteVisibility("unknown"),
+    /must be one of/
+  );
 });
 
 test("isWorkspaceVisibility recognizes workspace-only visibility levels", () => {