@jskit-ai/users-core 0.1.172 → 0.1.173

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

@@ -64,7 +64,11 @@ function normalizeLifecycleContributors(entries = []) {
   );
 }
 
-function createService({ userProfilesRepository, lifecycleContributors = [], userSettingsRepository = null } = {}) {
+function createService({
+  userProfilesRepository,
+  resolveLifecycleContributors = () => [],
+  userSettingsRepository = null
+} = {}) {
   if (!userProfilesRepository || typeof userProfilesRepository.findByIdentity !== "function") {
     throw new Error("authProfileSyncService requires userProfilesRepository.findByIdentity().");
   }
@@ -78,7 +82,9 @@ function createService({ userProfilesRepository, lifecycleContributors = [], use
     throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
   }
 
-  const normalizedLifecycleContributors = normalizeLifecycleContributors(lifecycleContributors);
+  if (typeof resolveLifecycleContributors !== "function") {
+    throw new Error("authProfileSyncService requires resolveLifecycleContributors().");
+  }
 
   async function findByIdentity(identityLike, options = {}) {
     const normalized = buildNormalizedIdentityKey(identityLike);
@@ -107,6 +113,7 @@ function createService({ userProfilesRepository, lifecycleContributors = [], use
 
   async function syncIdentityProfile(profileLike, options = {}) {
     const normalized = buildNormalizedIdentityProfile(profileLike);
+    const lifecycleContributors = normalizeLifecycleContributors(resolveLifecycleContributors());
 
     const runSync = async (trx = null) => {
       const operationOptions = trx ? { ...options, trx } : options;
@@ -115,7 +122,7 @@ function createService({ userProfilesRepository, lifecycleContributors = [], use
       if (!profileNeedsUpdate(existing, normalized)) {
         const synchronizedProfile = requireSynchronizedProfile(existing);
         await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
-        for (const contributor of normalizedLifecycleContributors) {
+        for (const contributor of lifecycleContributors) {
           await contributor.afterIdentityProfileSynced({
             profile: synchronizedProfile,
             created,
@@ -129,7 +136,7 @@ function createService({ userProfilesRepository, lifecycleContributors = [], use
       const synchronizedProfile = requireSynchronizedProfile(upserted);
       await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
       created = !existing;
-      for (const contributor of normalizedLifecycleContributors) {
+      for (const contributor of lifecycleContributors) {
         await contributor.afterIdentityProfileSynced({
           profile: synchronizedProfile,
           created,

package/src/server/common/support/realtimeServiceEvents.js

@@ -1,13 +1,11 @@
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { deepFreeze } from "./deepFreeze.js";
+import { createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
 
-function resolveActorScopedEntityId({ options } = {}) {
-  return normalizeRecordId(options?.context?.actor?.id, { fallback: "" });
+function resolveActorScopedEntityId({ context } = {}) {
+  return context?.actor?.id;
 }
 
-const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
-  {
-    type: "entity.changed",
+const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = Object.freeze([
+  createEntityChangedActionEvent({
     source: "account",
     entity: "settings",
     operation: "updated",
@@ -16,9 +14,8 @@ const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
       event: "account.settings.changed",
       audience: "actor_user"
     }
-  },
-  {
-    type: "entity.changed",
+  }),
+  createEntityChangedActionEvent({
     source: "users",
     entity: "bootstrap",
     operation: "updated",
@@ -27,7 +24,7 @@ const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
       event: "users.bootstrap.changed",
       audience: "actor_user"
     }
-  }
+  })
 ]);
 
 export { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS };

package/src/server/usersBootstrapContributor.js

@@ -1,7 +1,7 @@
 import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeBoolean, normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
 import { accountAvatarFormatter } from "./common/formatters/accountAvatarFormatter.js";
 import { USER_SETTINGS_BOOTSTRAP_KEYS } from "../shared/resources/userSettingsResource.js";
 
@@ -30,34 +30,13 @@ function getOAuthProviderCatalogPayload(authService) {
   };
 }
 
-function resolveBooleanConfigValue(value, fallback) {
-  if (value === undefined || value === null || value === "") {
-    return fallback;
-  }
-
-  return normalizeBoolean(value);
-}
-
-function resolveAppState(appConfig = {}) {
-  const features = {
-    assistantEnabled: resolveBooleanConfigValue(appConfig.assistantEnabled, false),
-    assistantRequiredPermission: normalizeText(appConfig.assistantRequiredPermission),
-    socialEnabled: resolveBooleanConfigValue(appConfig.socialEnabled, false),
-    socialFederationEnabled: resolveBooleanConfigValue(appConfig.socialFederationEnabled, false)
-  };
-
-  return {
-    features
-  };
-}
-
-function createAnonymousBootstrapPayload({ appState, surfaceAccess = {} }) {
+function createAnonymousBootstrapPayload({ surfaceAccess = {} }) {
   return {
     session: {
       authenticated: false
     },
     profile: null,
-    app: appState,
+    app: {},
     surfaceAccess: normalizeObject(surfaceAccess),
     userSettings: null,
     requestMeta: {
@@ -80,11 +59,9 @@ function mapUserSettingsBootstrap(settings = {}) {
 function createUsersBootstrapContributor({
   userProfilesRepository,
   userSettingsRepository,
-  appConfig = {},
   authService
 } = {}) {
   const contributorId = "users.bootstrap";
-  const appState = resolveAppState(appConfig);
 
   requireServiceMethod(userProfilesRepository, "findById", contributorId, {
     serviceLabel: "internal.repository.user-profiles"
@@ -114,7 +91,6 @@ function createUsersBootstrapContributor({
       const normalizedUser = authResult?.authenticated === true ? authResult?.actor || null : null;
       const inheritedSurfaceAccess = normalizeObject(existingPayload?.surfaceAccess);
       let payload = createAnonymousBootstrapPayload({
-        appState,
         surfaceAccess: inheritedSurfaceAccess
       });
 
@@ -132,7 +108,7 @@ function createUsersBootstrapContributor({
             email: latestProfile.email,
             avatar: accountAvatarFormatter(latestProfile, userSettings)
           },
-          app: appState,
+          app: {},
           surfaceAccess: inheritedSurfaceAccess,
           userSettings: mapUserSettingsBootstrap(userSettings),
           requestMeta: {

package/src/server/usersExtensions.js

@@ -0,0 +1,65 @@
+function normalizeContributor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError("Profile synchronization lifecycle contributor must be an object.");
+  }
+  const contributorId = String(value.contributorId || "").trim();
+  if (!contributorId) {
+    throw new TypeError("Profile synchronization lifecycle contributor requires contributorId.");
+  }
+  if (typeof value.afterIdentityProfileSynced !== "function") {
+    throw new TypeError(`Profile synchronization lifecycle contributor "${contributorId}" requires afterIdentityProfileSynced().`);
+  }
+  return Object.freeze({
+    ...value,
+    contributorId,
+    order: Number.isFinite(value.order) ? Number(value.order) : 0,
+    afterIdentityProfileSynced: value.afterIdentityProfileSynced
+  });
+}
+
+function createUsersExtensions() {
+  const contributors = [];
+  const contributorIds = new Set();
+  let sealed = false;
+
+  function registerProfileSyncLifecycleContributor(value) {
+    if (sealed) {
+      throw new Error("User extension registration is closed after profile synchronization starts.");
+    }
+    const contributor = normalizeContributor(value);
+    if (contributorIds.has(contributor.contributorId)) {
+      throw new Error(`Profile synchronization lifecycle contributor "${contributor.contributorId}" is duplicated.`);
+    }
+    contributorIds.add(contributor.contributorId);
+    contributors.push(contributor);
+    return api;
+  }
+
+  function profileSyncLifecycleContributors() {
+    sealed = true;
+    return Object.freeze(
+      contributors
+        .map((contributor, index) => ({ contributor, index }))
+        .sort((left, right) => left.contributor.order - right.contributor.order || left.index - right.index)
+        .map(({ contributor }) => contributor)
+    );
+  }
+
+  function diagnostics() {
+    return Object.freeze({
+      sealed,
+      profileSyncLifecycleContributorIds: Object.freeze(
+        contributors.map((entry) => entry.contributorId).sort()
+      )
+    });
+  }
+
+  const api = Object.freeze({
+    registerProfileSyncLifecycleContributor,
+    profileSyncLifecycleContributors,
+    diagnostics
+  });
+  return api;
+}
+
+export { createUsersExtensions };

package/test/authProfileSyncService.test.js

@@ -33,7 +33,7 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
         return { userId: Number(userId) };
       }
     },
-    lifecycleContributors: [
+    resolveLifecycleContributors: () => [
       {
         contributorId: "test.lifecycle",
         async afterIdentityProfileSynced({ created, options = {} } = {}) {
@@ -91,7 +91,7 @@ test("authProfileSyncService.syncIdentityProfile skips write path when profile i
         return { userId: "7" };
       }
     },
-    lifecycleContributors: [
+    resolveLifecycleContributors: () => [
       {
         contributorId: "test.lifecycle",
         async afterIdentityProfileSynced({ created } = {}) {

package/test/exportsContract.test.js

@@ -12,7 +12,12 @@ test("users-core exports are explicit and aligned with production/template usage
   const result = evaluatePackageExportsContract({
     repoRoot: REPO_ROOT,
     packageDir: PACKAGE_DIR,
-    packageId: "@jskit-ai/users-core"
+    packageId: "@jskit-ai/users-core",
+    requiredExports: [
+      "./server/UsersFeature",
+      "./server/UsersIdentityProvider",
+      "./server/usersExtensions"
+    ]
   });
 
   assert.deepEqual(

package/test/featureRuntime.test.js

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { createBootstrapRuntime } from "@jskit-ai/kernel/server/runtime";
+import { createAuthExtensions } from "@jskit-ai/auth-core/server/authExtensions";
+import { UsersExtensionsProvider } from "../src/server/UsersExtensionsProvider.js";
+import { UsersFeature } from "../src/server/UsersFeature.js";
+import { UsersIdentityProvider } from "../src/server/UsersIdentityProvider.js";
+
+function createJsonRestApiFixture() {
+  const resources = {};
+  return {
+    resources,
+    async addResource(scopeName) {
+      resources[scopeName] = Object.freeze({
+        query: async () => ({ data: [] }),
+        post: async () => null,
+        patch: async () => null
+      });
+    }
+  };
+}
+
+test("UsersFeature assembles account behavior through explicit capabilities", async () => {
+  const routes = [];
+  const bootstrap = createBootstrapRuntime();
+  const authExtensions = createAuthExtensions();
+  const jsonRestApi = createJsonRestApiFixture();
+  let users = null;
+  let actionCatalogue = null;
+  const probe = defineProvider({
+    id: "test.users.probe",
+    requires: {
+      actions: "runtime.actions",
+      usersCapability: "users.core"
+    },
+    setup({ actions, usersCapability }) {
+      actionCatalogue = actions;
+      users = usersCapability;
+      return {};
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    inputs: {
+      "auth.extensions": authExtensions,
+      "auth.service": {},
+      "runtime.bootstrap": bootstrap,
+      "runtime.database": { knex() {} },
+      "runtime.http": {
+        router: {
+          register(method, path) {
+            routes.push(`${method} ${path}`);
+          }
+        }
+      },
+      "runtime.json-rest-api": jsonRestApi,
+      "runtime.storage": {
+        async getItemRaw() { return null; },
+        async setItemRaw() {},
+        async removeItem() {}
+      },
+      "runtime.uploads": { readSingleMultipartFile() {} }
+    },
+    providers: [createActionProvider(), UsersExtensionsProvider, UsersIdentityProvider, UsersFeature, probe]
+  });
+
+  await runtime.start();
+
+  assert.deepEqual(Object.keys(jsonRestApi.resources).sort(), ["userProfiles", "userSettings"]);
+  assert.equal(typeof users.repositories.userProfiles.findByIdentity, "function");
+  assert.equal(typeof users.services.accountProfile.updateProfile, "function");
+  assert.equal(routes.includes("GET /api/settings"), true);
+  assert.equal(routes.includes("POST /api/settings/security/change-password"), true);
+  assert.equal(actionCatalogue.listDefinitions().length, 11);
+  assert.deepEqual(bootstrap.diagnostics().contributorIds, ["users.bootstrap"]);
+  assert.equal(authExtensions.resolveProfileProjector().projectorId, "users.profile");
+});

package/test/usersBootstrapContributor.test.js

@@ -93,7 +93,7 @@ test("users bootstrap contributor exposes the generic authenticated bootstrap pa
   assert.deepEqual(payload.surfaceAccess, {
     consoleowner: true
   });
-  assert.equal(payload.app.features.assistantEnabled, false);
+  assert.deepEqual(payload.app, {});
   assert.deepEqual(payload.session.oauthProviders, [
     {
       id: "google",
@@ -117,9 +117,6 @@ test("users bootstrap contributor emits anonymous bootstrap payload without work
         return createUserSettings();
       }
     },
-    appConfig: {
-      tenancyMode: "none"
-    },
     authService: {
       getOAuthProviderCatalog() {
         return {
@@ -156,42 +153,3 @@ test("users bootstrap contributor emits anonymous bootstrap payload without work
   });
   assert.equal(payload.userSettings, null);
 });
-
-test("users bootstrap contributor uses shared boolean normalization for app feature flags", async () => {
-  const contributor = createUsersBootstrapContributor({
-    userProfilesRepository: {
-      async findById() {
-        return null;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return createUserSettings();
-      }
-    },
-    appConfig: {
-      assistantEnabled: "yes",
-      socialEnabled: 0,
-      socialFederationEnabled: "no"
-    }
-  });
-
-  const payload = await contributor.contribute({
-    request: {
-      async executeAction() {
-        return {
-          authenticated: false
-        };
-      }
-    },
-    payload: {},
-    reply: {}
-  });
-
-  assert.deepEqual(payload.app.features, {
-    assistantEnabled: true,
-    assistantRequiredPermission: "",
-    socialEnabled: false,
-    socialFederationEnabled: false
-  });
-});