@jskit-ai/users-core 0.1.47 → 0.1.49

package/src/server/workspacePendingInvitations/workspacePendingInvitationsService.js

@@ -1,138 +0,0 @@
-import { resolveInviteTokenHash } from "@jskit-ai/auth-core/server/inviteTokens";
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { authenticatedUserValidator } from "../common/validators/authenticatedUserValidator.js";
-
-function createService({
-  workspaceInvitesRepository,
-  workspaceMembershipsRepository
-} = {}) {
-  if (!workspaceInvitesRepository || !workspaceMembershipsRepository) {
-    throw new Error("workspacePendingInvitationsService requires invite and membership repositories.");
-  }
-
-  function requireAuthenticatedInviteUser(user) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      throw new AppError(401, "Authentication required.");
-    }
-
-    return normalizedUser;
-  }
-
-  function requireInviteTokenHash(token) {
-    const normalizedToken = normalizeText(token);
-    if (!normalizedToken) {
-      throw new AppError(400, "Invite token is required.");
-    }
-
-    const tokenHash = resolveInviteTokenHash(normalizedToken);
-    if (!tokenHash) {
-      throw new AppError(400, "Invite token is invalid.");
-    }
-
-    return tokenHash;
-  }
-
-  async function requirePendingInviteForUserByToken(user, token, options = {}) {
-    const normalizedUser = requireAuthenticatedInviteUser(user);
-    const tokenHash = requireInviteTokenHash(token);
-
-    const invite = await workspaceInvitesRepository.findPendingByTokenHash(tokenHash, options);
-    if (!invite) {
-      throw new AppError(404, "Invitation not found or already handled.");
-    }
-
-    if (normalizeLowerText(invite.email) !== normalizedUser.email) {
-      throw new AppError(403, "Invitation email does not match authenticated user.");
-    }
-
-    return {
-      user: normalizedUser,
-      invite
-    };
-  }
-
-  async function revokeExpiredInviteAndThrow(invite, options = {}) {
-    if (invite.expiresAt && new Date(invite.expiresAt).getTime() < Date.now()) {
-      await workspaceInvitesRepository.revokeById(invite.id, options);
-      throw new AppError(409, "Invitation has expired.");
-    }
-  }
-
-  async function listPendingInvitesForUser(user, options = {}) {
-    const normalizedUser = requireAuthenticatedInviteUser(user);
-    if (!normalizedUser.email) {
-      return [];
-    }
-
-    return workspaceInvitesRepository.listPendingByEmail(normalizedUser.email, options);
-  }
-
-  function requireWorkspaceIdFromInvite(invite, methodName = "workspacePendingInvitationsService") {
-    const workspaceId = normalizeRecordId(invite?.workspaceId, { fallback: null });
-    if (!workspaceId) {
-      throw new Error(`${methodName} expected invite workspace id.`);
-    }
-    return workspaceId;
-  }
-
-  async function resolveInviteActionInput(user, token, options = {}, methodName = "workspacePendingInvitationsService") {
-    const resolvedInvite = await requirePendingInviteForUserByToken(user, token, options);
-    await revokeExpiredInviteAndThrow(resolvedInvite.invite, options);
-
-    return {
-      resolvedInvite,
-      workspaceId: requireWorkspaceIdFromInvite(resolvedInvite.invite, methodName)
-    };
-  }
-
-  async function acceptInviteByToken({ user, token } = {}, options = {}) {
-    const { resolvedInvite, workspaceId } = await resolveInviteActionInput(
-      user,
-      token,
-      options,
-      "workspacePendingInvitationsService.acceptInviteByToken"
-    );
-
-    await workspaceMembershipsRepository.upsertMembership(
-      workspaceId,
-      resolvedInvite.user.id,
-      {
-        roleSid: resolvedInvite.invite.roleSid,
-        status: "active"
-      },
-      options
-    );
-    await workspaceInvitesRepository.markAcceptedById(resolvedInvite.invite.id, options);
-
-    return {
-      decision: "accepted",
-      workspaceId
-    };
-  }
-
-  async function refuseInviteByToken({ user, token } = {}, options = {}) {
-    const { resolvedInvite, workspaceId } = await resolveInviteActionInput(
-      user,
-      token,
-      options,
-      "workspacePendingInvitationsService.refuseInviteByToken"
-    );
-    await workspaceInvitesRepository.revokeById(resolvedInvite.invite.id, options);
-
-    return {
-      decision: "refused",
-      workspaceId
-    };
-  }
-
-  return Object.freeze({
-    listPendingInvitesForUser,
-    acceptInviteByToken,
-    refuseInviteByToken
-  });
-}
-
-export { createService };

package/src/server/workspaceSettings/bootWorkspaceSettings.js

@@ -1,76 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
-import { resolveWorkspaceRoutePath } from "../common/support/workspaceRoutePaths.js";
-import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
-import { resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig } from "../support/workspaceActionSurfaces.js";
-
-function bootWorkspaceSettings(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspaceSettings requires application make().");
-  }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = typeof app.has === "function" && app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
-
-  router.register(
-    "GET",
-    resolveWorkspaceRoutePath("/settings"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      meta: {
-        tags: ["workspace"],
-        summary: "Get workspace settings and role catalog by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceSettingsResource.operations.view.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.settings.read",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    resolveWorkspaceRoutePath("/settings"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      meta: {
-        tags: ["workspace"],
-        summary: "Update workspace settings by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      bodyValidator: workspaceSettingsResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: workspaceSettingsResource.operations.patch.outputValidator
-        },
-        { includeValidation400: true }
-      )
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.settings.update",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          patch: request.input.body
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { bootWorkspaceSettings };

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -1,62 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { deepFreeze } from "../common/support/deepFreeze.js";
-import { createRepository as createWorkspaceSettingsRepository } from "./workspaceSettingsRepository.js";
-import { createService as createWorkspaceSettingsService } from "./workspaceSettingsService.js";
-import { workspaceSettingsActions } from "./workspaceSettingsActions.js";
-import { createWorkspaceRoleCatalog } from "../../shared/roles.js";
-import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
-
-function resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig = {}) {
-  const defaultInvitesEnabled = appConfig?.workspaceSettings?.defaults?.invitesEnabled;
-
-  if (typeof defaultInvitesEnabled !== "boolean") {
-    throw new TypeError("users.core requires appConfig.workspaceSettings.defaults.invitesEnabled.");
-  }
-
-  return defaultInvitesEnabled;
-}
-
-function registerWorkspaceSettings(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.actions !== "function" || typeof app.service !== "function") {
-    throw new Error("registerWorkspaceSettings requires application singleton()/service()/actions().");
-  }
-
-  app.singleton("workspaceSettingsRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceSettingsRepository(knex, {
-      defaultInvitesEnabled: resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig)
-    });
-  });
-
-  app.service(
-    "users.workspace.settings.service",
-    (scope) =>
-      createWorkspaceSettingsService({
-        workspaceSettingsRepository: scope.make("workspaceSettingsRepository"),
-        workspaceInvitationsEnabled: scope.make("users.workspace.invitations.enabled"),
-        roleCatalog: createWorkspaceRoleCatalog(resolveAppConfig(scope))
-      }),
-    {
-      events: deepFreeze({
-        updateWorkspaceSettings: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "settings",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.settings.changed"
-        })
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(workspaceSettingsActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceSettingsService: "users.workspace.settings.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceSettings };

package/src/server/workspaceSettings/workspaceSettingsActions.js

@@ -1,72 +0,0 @@
-import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
-import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
-import { resolveWorkspace } from "../support/resolveWorkspace.js";
-
-const workspaceSettingsActions = Object.freeze([
-  {
-    id: "workspace.settings.read",
-    version: 1,
-    kind: "query",
-    channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
-    permission: {
-      require: "any",
-      permissions: ["workspace.settings.view", "workspace.settings.update"]
-    },
-    inputValidator: workspaceSlugParamsValidator,
-    outputValidator: workspaceSettingsResource.operations.view.outputValidator,
-    idempotency: "none",
-    audit: {
-      actionName: "workspace.settings.read"
-    },
-    observability: {},
-    async execute(input, context, deps) {
-      const response = await deps.workspaceSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
-        context
-      });
-
-      return response;
-    }
-  },
-  {
-    id: "workspace.settings.update",
-    version: 1,
-    kind: "command",
-    channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
-    permission: {
-      require: "all",
-      permissions: ["workspace.settings.update"]
-    },
-    inputValidator: [
-      workspaceSlugParamsValidator,
-      {
-        patch: workspaceSettingsResource.operations.patch.bodyValidator
-      }
-    ],
-    outputValidator: workspaceSettingsResource.operations.patch.outputValidator,
-    idempotency: "optional",
-    audit: {
-      actionName: "workspace.settings.update"
-    },
-    observability: {},
-    extensions: {
-      assistant: {
-        description: "Update workspace settings."
-      }
-    },
-    async execute(input, context, deps) {
-      const response = await deps.workspaceSettingsService.updateWorkspaceSettings(
-        resolveWorkspace(context, input),
-        input.patch,
-        {
-          context
-        }
-      );
-
-      return response;
-    }
-  }
-]);
-
-export { workspaceSettingsActions };

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -1,154 +0,0 @@
-import {
-  normalizeDbRecordId,
-  normalizeRecordId,
-  toIsoString,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
-} from "../common/repositories/repositoryUtils.js";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
-import {
-  workspaceSettingsFields,
-  resolveWorkspaceSettingsFieldKeys
-} from "../../shared/resources/workspaceSettingsFields.js";
-
-function resolveWorkspaceSettingsSeed(workspace = {}, { defaultInvitesEnabled = true } = {}) {
-  const source = normalizeObjectInput(workspace);
-  const seed = {};
-  for (const field of workspaceSettingsFields) {
-    const rawValue = Object.hasOwn(source, field.key)
-      ? source[field.key]
-      : field.resolveDefault({
-          workspace: source,
-          defaultInvitesEnabled
-        });
-    seed[field.key] = field.normalizeOutput(rawValue, {
-      workspace: source,
-      defaultInvitesEnabled
-    });
-  }
-  return seed;
-}
-
-function createRepository(knex, { defaultInvitesEnabled } = {}) {
-  if (typeof knex !== "function") {
-    throw new TypeError("workspaceSettingsRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
-
-  function mapRow(row) {
-    if (!row) {
-      return null;
-    }
-
-    const settings = {
-      workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" })
-    };
-    for (const field of workspaceSettingsFields) {
-      const rawValue = Object.hasOwn(row, field.dbColumn)
-        ? row[field.dbColumn]
-        : field.resolveDefault({
-            defaultInvitesEnabled
-          });
-      settings[field.key] = field.normalizeOutput(rawValue, {
-        defaultInvitesEnabled
-      });
-    }
-
-    settings.createdAt = toIsoString(row.created_at);
-    settings.updatedAt = toIsoString(row.updated_at);
-    return settings;
-  }
-
-  async function findByWorkspaceId(workspaceId, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return null;
-    }
-
-    const row = await client("workspace_settings").where({ workspace_id: normalizedWorkspaceId }).first();
-    return mapRow(row);
-  }
-
-  async function ensureForWorkspaceId(workspaceId, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      throw new TypeError("workspaceSettingsRepository.ensureForWorkspaceId requires a valid workspace id.");
-    }
-
-    const seed = resolveWorkspaceSettingsSeed(options?.workspace, {
-      defaultInvitesEnabled
-    });
-    const existing = await findByWorkspaceId(normalizedWorkspaceId, { trx: client });
-    if (existing) {
-      return existing;
-    }
-
-    try {
-      const insertPayload = {
-        workspace_id: normalizedWorkspaceId,
-        created_at: nowDb(),
-        updated_at: nowDb()
-      };
-      for (const field of workspaceSettingsFields) {
-        insertPayload[field.dbColumn] = seed[field.key];
-      }
-      await client("workspace_settings").insert(insertPayload);
-    } catch (error) {
-      if (!isDuplicateEntryError(error)) {
-        throw error;
-      }
-    }
-
-    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
-  }
-
-  async function updateSettingsByWorkspaceId(workspaceId, patch = {}, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      throw new TypeError("workspaceSettingsRepository.updateSettingsByWorkspaceId requires a valid workspace id.");
-    }
-
-    const ensured = await ensureForWorkspaceId(normalizedWorkspaceId, {
-      trx: client,
-      workspace: options?.workspace
-    });
-    const source = normalizeObjectInput(patch);
-    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
-
-    if (Object.keys(settingsPatch).length === 0) {
-      return ensured;
-    }
-
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-    for (const field of workspaceSettingsFields) {
-      if (!Object.hasOwn(settingsPatch, field.key)) {
-        continue;
-      }
-      dbPatch[field.dbColumn] = field.normalizeInput(settingsPatch[field.key], {
-        payload: source
-      });
-    }
-
-    await client("workspace_settings").where({ workspace_id: normalizedWorkspaceId }).update({
-      ...dbPatch
-    });
-    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
-  }
-
-  return Object.freeze({
-    withTransaction,
-    findByWorkspaceId,
-    ensureForWorkspaceId,
-    updateSettingsByWorkspaceId
-  });
-}
-
-export { createRepository };

package/src/server/workspaceSettings/workspaceSettingsService.js

@@ -1,66 +0,0 @@
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
-import {
-  workspaceSettingsFields,
-  resolveWorkspaceSettingsFieldKeys
-} from "../../shared/resources/workspaceSettingsFields.js";
-import { createWorkspaceRoleCatalog, cloneWorkspaceRoleCatalog } from "../../shared/roles.js";
-
-function createService({
-  workspaceSettingsRepository,
-  workspaceInvitationsEnabled = true,
-  roleCatalog = null
-} = {}) {
-  if (!workspaceSettingsRepository) {
-    throw new Error("workspaceSettingsService requires workspaceSettingsRepository.");
-  }
-  const resolvedRoleCatalog = roleCatalog && typeof roleCatalog === "object" ? roleCatalog : createWorkspaceRoleCatalog();
-  const invitesAvailable = workspaceInvitationsEnabled === true;
-
-  async function getWorkspaceSettings(workspace, options = {}) {
-    const settingsRecord = await workspaceSettingsRepository.ensureForWorkspaceId(workspace.id, {
-      ...options,
-      workspace
-    });
-    const settings = {};
-    for (const field of workspaceSettingsFields) {
-      settings[field.key] = settingsRecord[field.key];
-    }
-    const invitesEnabled = invitesAvailable && settings.invitesEnabled !== false;
-    settings.invitesEnabled = invitesEnabled;
-    settings.invitesAvailable = invitesAvailable;
-    settings.invitesEffective = invitesAvailable && invitesEnabled;
-
-    return {
-      workspace: {
-        id: normalizeRecordId(workspace.id, { fallback: "" }),
-        slug: String(workspace.slug || ""),
-        ownerUserId: normalizeRecordId(workspace.ownerUserId, { fallback: "" })
-      },
-      settings,
-      roleCatalog: cloneWorkspaceRoleCatalog(resolvedRoleCatalog)
-    };
-  }
-
-  async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
-    const source = normalizeObjectInput(payload);
-    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
-
-    if (Object.keys(settingsPatch).length > 0) {
-      await workspaceSettingsRepository.updateSettingsByWorkspaceId(workspace.id, settingsPatch, {
-        ...options,
-        workspace
-      });
-    }
-
-    return getWorkspaceSettings(workspace, options);
-  }
-
-  return Object.freeze({
-    getWorkspaceSettings,
-    updateWorkspaceSettings
-  });
-}
-
-export { createService };

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
-};