@jskit-ai/users-core 0.1.4

package/src/server/consoleSettings/consoleSettingsRepository.js

@@ -0,0 +1,111 @@
+import {
+  nowDb,
+  toIsoString
+} from "../common/repositories/repositoryUtils.js";
+import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+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 = parsePositiveInteger(row.owner_user_id);
+  return {
+    id: Number(row.id),
+    ownerUserId: ownerUserId || null,
+    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.");
+  }
+
+  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 = parsePositiveInteger(userId);
+    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({
+    getSingleton,
+    ensureOwnerUserId,
+    updateSingleton
+  });
+}
+
+export { createRepository };

package/src/server/consoleSettings/consoleSettingsService.js

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,57 @@
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { CONSOLE_SETTINGS_CHANGED_EVENT } from "../../shared/events/usersEvents.js";
+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_EVENT,
+              audience: "all_users"
+            })
+          })
+        ])
+      })
+    }
+  );
+
+  app.actions(
+    withActionDefaults(consoleSettingsActions, {
+      domain: "console",
+      dependencies: {
+        consoleSettingsService: "users.console.settings.service"
+      }
+    })
+  );
+}
+
+export { registerConsoleSettings };

package/src/server/registerWorkspaceBootstrap.js

@@ -0,0 +1,36 @@
+import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import {
+  USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN,
+  USERS_TENANCY_PROFILE_TOKEN,
+  USERS_WORKSPACE_PENDING_INVITATIONS_SERVICE_TOKEN
+} from "./common/diTokens.js";
+import { createWorkspaceBootstrapContributor } from "./workspaceBootstrapContributor.js";
+
+const USERS_WORKSPACE_BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TOKEN = "users.core.workspace.bootstrap.payloadContributor";
+
+function registerWorkspaceBootstrap(app) {
+  if (!app || typeof app.singleton !== "function") {
+    throw new Error("registerWorkspaceBootstrap requires application singleton().");
+  }
+
+  registerBootstrapPayloadContributor(app, USERS_WORKSPACE_BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TOKEN, (scope) => {
+    const workspaceInvitationsEnabled = scope.make(USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN);
+
+    return createWorkspaceBootstrapContributor({
+      workspaceService: scope.make("users.workspace.service"),
+      workspacePendingInvitationsService: workspaceInvitationsEnabled
+        ? scope.make(USERS_WORKSPACE_PENDING_INVITATIONS_SERVICE_TOKEN)
+        : null,
+      workspaceInvitationsEnabled,
+      userProfilesRepository: scope.make("userProfilesRepository"),
+      userSettingsRepository: scope.make("userSettingsRepository"),
+      appConfig: resolveAppConfig(scope),
+      tenancyProfile: scope.make(USERS_TENANCY_PROFILE_TOKEN),
+      authService: scope.make("authService"),
+      consoleService: scope.has("consoleService") ? scope.make("consoleService") : null
+    });
+  });
+}
+
+export { registerWorkspaceBootstrap };

package/src/server/registerWorkspaceCore.js

@@ -0,0 +1,95 @@
+import { AUTH_POLICY_CONTEXT_RESOLVER_TOKEN } from "@jskit-ai/auth-core/server/lib/tokens";
+import {
+  registerActionContextContributor
+} from "@jskit-ai/kernel/server/actions";
+import { registerRouteVisibilityResolver } from "@jskit-ai/kernel/server/http";
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { TENANCY_MODE_WORKSPACE, resolveTenancyProfile } from "../shared/tenancyProfile.js";
+import { createService as createWorkspaceService } from "./common/services/workspaceContextService.js";
+import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
+import { createWorkspaceActionContextContributor } from "./common/contributors/workspaceActionContextContributor.js";
+import { createWorkspaceRouteVisibilityResolver } from "./common/contributors/workspaceRouteVisibilityResolver.js";
+import { createWorkspaceAuthPolicyContextResolver } from "./common/contributors/workspaceAuthPolicyContextResolver.js";
+import { resolveWorkspaceInvitationsPolicy } from "./support/workspaceInvitationsPolicy.js";
+import {
+  USERS_PROFILE_SYNC_SERVICE_TOKEN,
+  USERS_TENANCY_PROFILE_TOKEN,
+  USERS_WORKSPACE_ENABLED_TOKEN,
+  USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN,
+  USERS_WORKSPACE_SELF_CREATE_ENABLED_TOKEN,
+  USERS_WORKSPACE_TENANCY_ENABLED_TOKEN
+} from "./common/diTokens.js";
+
+const USERS_WORKSPACE_CONTEXT_CONTRIBUTOR_TOKEN = "users.core.workspace.actionContextContributor";
+const USERS_WORKSPACE_VISIBILITY_RESOLVER_TOKEN = "users.core.workspace.routeVisibilityResolver";
+
+function registerWorkspaceCore(app) {
+  if (!app || typeof app.singleton !== "function") {
+    throw new Error("registerWorkspaceCore requires application singleton().");
+  }
+
+  app.singleton("users.workspace.service", (scope) => {
+    const appConfig = resolveAppConfig(scope);
+    return createWorkspaceService({
+      appConfig,
+      workspacesRepository: scope.make("workspacesRepository"),
+      workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository"),
+      workspaceSettingsRepository: scope.make("workspaceSettingsRepository")
+    });
+  });
+
+  app.singleton(USERS_PROFILE_SYNC_SERVICE_TOKEN, (scope) => {
+    return createAuthProfileSyncService({
+      userProfilesRepository: scope.make("userProfilesRepository"),
+      workspaceProvisioningService: scope.make("users.workspace.service")
+    });
+  });
+
+  app.singleton(USERS_TENANCY_PROFILE_TOKEN, (scope) => {
+    const appConfig = resolveAppConfig(scope);
+    return resolveTenancyProfile(appConfig);
+  });
+
+  app.singleton(USERS_WORKSPACE_ENABLED_TOKEN, (scope) => {
+    return scope.make(USERS_TENANCY_PROFILE_TOKEN).workspace.enabled === true;
+  });
+
+  app.singleton(USERS_WORKSPACE_SELF_CREATE_ENABLED_TOKEN, (scope) => {
+    return scope.make(USERS_TENANCY_PROFILE_TOKEN).workspace.allowSelfCreate === true;
+  });
+
+  app.singleton(USERS_WORKSPACE_TENANCY_ENABLED_TOKEN, (scope) => {
+    return scope.make(USERS_TENANCY_PROFILE_TOKEN).mode === TENANCY_MODE_WORKSPACE;
+  });
+
+  app.singleton(USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN, (scope) => {
+    const appConfig = resolveAppConfig(scope);
+    const tenancyProfile = scope.make(USERS_TENANCY_PROFILE_TOKEN);
+    return resolveWorkspaceInvitationsPolicy({
+      appConfig,
+      tenancyProfile
+    }).enabled;
+  });
+
+  registerActionContextContributor(app, USERS_WORKSPACE_CONTEXT_CONTRIBUTOR_TOKEN, (scope) => {
+    return createWorkspaceActionContextContributor({
+      workspaceService: scope.make("users.workspace.service")
+    });
+  });
+
+  if (typeof app.has !== "function" || !app.has(AUTH_POLICY_CONTEXT_RESOLVER_TOKEN)) {
+    app.singleton(AUTH_POLICY_CONTEXT_RESOLVER_TOKEN, (scope) =>
+      createWorkspaceAuthPolicyContextResolver({
+        workspaceService: scope.make("users.workspace.service")
+      })
+    );
+  }
+
+  registerRouteVisibilityResolver(app, USERS_WORKSPACE_VISIBILITY_RESOLVER_TOKEN, (scope) =>
+    createWorkspaceRouteVisibilityResolver({
+      workspaceService: scope.make("users.workspace.service")
+    })
+  );
+}
+
+export { registerWorkspaceCore };

package/src/server/support/resolveWorkspace.js

@@ -0,0 +1,16 @@
+import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+
+function resolveRequest(context = {}) {
+  const requestMeta = normalizeObject(context?.requestMeta);
+  return normalizeObject(requestMeta.request);
+}
+
+function resolveWorkspace(context = {}, input = {}) {
+  const payload = normalizeObject(input);
+  const requestMeta = normalizeObject(context?.requestMeta);
+  const resolvedWorkspaceContext = normalizeObject(requestMeta.resolvedWorkspaceContext);
+
+  return payload.workspace || resolvedWorkspaceContext.workspace || context?.workspace || resolveRequest(context)?.workspace || null;
+}
+
+export { resolveWorkspace };

package/src/server/support/workspaceActionSurfaces.js

@@ -0,0 +1,135 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { isRecord, normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveDefaultWorkspaceSurfaceId } from "../../shared/support/workspacePathModel.js";
+
+const CONSOLE_OWNER_ACCESS_POLICY_ID = "console_owner";
+
+function normalizeSurfaceIds(surfaceIds = []) {
+  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
+  const seen = new Set();
+  const normalized = [];
+
+  for (const candidate of source) {
+    const surfaceId = normalizeSurfaceId(candidate);
+    if (!surfaceId || seen.has(surfaceId)) {
+      continue;
+    }
+    seen.add(surfaceId);
+    normalized.push(surfaceId);
+  }
+
+  return normalized;
+}
+
+function resolveWorkspaceSurfaceIdsFromAppConfig(appConfig = {}) {
+  return resolveSurfaceIdsFromAppConfig(appConfig, (definition) => definition.requiresWorkspace === true);
+}
+
+function resolveConsoleSurfaceIdsFromAppConfig(appConfig = {}) {
+  return resolveSurfaceIdsFromAppConfig(appConfig, (definition) => {
+    return (
+      definition.requiresWorkspace !== true &&
+      normalizeLowerText(definition.accessPolicyId) === CONSOLE_OWNER_ACCESS_POLICY_ID
+    );
+  });
+}
+
+function resolveSurfaceIdsFromAppConfig(appConfig = {}, predicate) {
+  const source = isRecord(appConfig?.surfaceDefinitions) ? appConfig.surfaceDefinitions : {};
+  const resolved = [];
+
+  for (const [key, value] of Object.entries(source)) {
+    const definition = isRecord(value) ? value : {};
+    const surfaceId = normalizeSurfaceId(definition.id || key);
+    if (!surfaceId) {
+      continue;
+    }
+    if (definition.enabled === false) {
+      continue;
+    }
+    if (typeof predicate === "function" && predicate(definition) === true) {
+      resolved.push(surfaceId);
+    }
+  }
+
+  return normalizeSurfaceIds(resolved);
+}
+
+function materializeWorkspaceActionSurfaces(actions = [], { workspaceSurfaceIds = [] } = {}) {
+  const sourceActions = Array.isArray(actions) ? actions : [];
+  const resolvedWorkspaceSurfaceIds = normalizeSurfaceIds(workspaceSurfaceIds);
+  const materialized = [];
+
+  for (const entry of sourceActions) {
+    const action = isRecord(entry) ? entry : {};
+    const surfacesFrom = String(action.surfacesFrom || "")
+      .trim()
+      .toLowerCase();
+    if (surfacesFrom !== "workspace") {
+      materialized.push(action);
+      continue;
+    }
+
+    if (resolvedWorkspaceSurfaceIds.length < 1) {
+      continue;
+    }
+
+    const { surfacesFrom: _ignored, ...rest } = action;
+    materialized.push({
+      ...rest,
+      surfaces: [...resolvedWorkspaceSurfaceIds]
+    });
+  }
+
+  return Object.freeze(materialized.map((entry) => Object.freeze({ ...entry })));
+}
+
+function registerUsersCoreActionSurfaceSources(app) {
+  if (!app || typeof app.actionSurfaceSource !== "function") {
+    return;
+  }
+
+  app.actionSurfaceSource("workspace", ({ scope }) => {
+    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
+    return resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
+  });
+
+  app.actionSurfaceSource("console", ({ scope }) => {
+    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
+    return resolveConsoleSurfaceIdsFromAppConfig(appConfig);
+  });
+}
+
+function materializeWorkspaceActionSurfacesFromAppConfig(actions = [], { appConfig = {} } = {}) {
+  const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
+  return materializeWorkspaceActionSurfaces(actions, { workspaceSurfaceIds });
+}
+
+function resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig = {}) {
+  const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
+  const workspaceSurfaceSet = new Set(workspaceSurfaceIds);
+
+  const resolvedSurfaceId = resolveDefaultWorkspaceSurfaceId({
+    defaultSurfaceId: appConfig?.surfaceDefaultId,
+    workspaceSurfaceIds,
+    surfaceRequiresWorkspace(surfaceId) {
+      return workspaceSurfaceSet.has(surfaceId);
+    }
+  });
+
+  return (
+    normalizeSurfaceId(resolvedSurfaceId) ||
+    normalizeSurfaceId(workspaceSurfaceIds[0]) ||
+    normalizeSurfaceId(appConfig?.surfaceDefaultId) ||
+    ""
+  );
+}
+
+export {
+  resolveWorkspaceSurfaceIdsFromAppConfig,
+  resolveConsoleSurfaceIdsFromAppConfig,
+  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
+  materializeWorkspaceActionSurfaces,
+  materializeWorkspaceActionSurfacesFromAppConfig,
+  registerUsersCoreActionSurfaceSources
+};

package/src/server/support/workspaceInvitationsPolicy.js

@@ -0,0 +1,45 @@
+import {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  normalizeTenancyMode
+} from "../../shared/tenancyMode.js";
+
+function normalizeWorkspaceInvitationsConfig(appConfig = {}) {
+  const source = appConfig && typeof appConfig === "object" && !Array.isArray(appConfig)
+    ? appConfig.workspaceInvitations
+    : null;
+  const normalizedSource = source && typeof source === "object" && !Array.isArray(source)
+    ? source
+    : {};
+
+  return Object.freeze({
+    enabled: normalizedSource.enabled !== false,
+    allowInPersonalMode: normalizedSource.allowInPersonalMode !== false
+  });
+}
+
+function resolveWorkspaceInvitationsPolicy({
+  appConfig = {},
+  tenancyProfile = null
+} = {}) {
+  const config = normalizeWorkspaceInvitationsConfig(appConfig);
+  const normalizedTenancyProfile = tenancyProfile && typeof tenancyProfile === "object"
+    ? tenancyProfile
+    : {};
+  const tenancyMode = normalizeTenancyMode(normalizedTenancyProfile.mode || appConfig?.tenancyMode);
+  const workspaceEnabled = normalizedTenancyProfile?.workspace?.enabled === true || tenancyMode !== TENANCY_MODE_NONE;
+  const enabledForTenancyMode = tenancyMode !== TENANCY_MODE_PERSONAL || config.allowInPersonalMode === true;
+  const enabled = config.enabled === true && workspaceEnabled && enabledForTenancyMode;
+
+  return Object.freeze({
+    enabled,
+    workspaceEnabled,
+    allowInPersonalMode: config.allowInPersonalMode,
+    tenancyMode
+  });
+}
+
+export {
+  normalizeWorkspaceInvitationsConfig,
+  resolveWorkspaceInvitationsPolicy
+};

package/src/server/support/workspaceRouteInput.js

@@ -0,0 +1,22 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function readWorkspaceSlugFromRouteParams(params = {}) {
+  const workspaceSlug = normalizeText(params?.workspaceSlug).toLowerCase();
+  return workspaceSlug || "";
+}
+
+function buildWorkspaceInputFromRouteParams(params = {}) {
+  const workspaceSlug = readWorkspaceSlugFromRouteParams(params);
+  if (!workspaceSlug) {
+    return {};
+  }
+
+  return {
+    workspaceSlug
+  };
+}
+
+export {
+  readWorkspaceSlugFromRouteParams,
+  buildWorkspaceInputFromRouteParams
+};