@jskit-ai/users-core 0.1.48 → 0.1.50

package/src/server/workspaceBootstrapContributor.js

@@ -1,212 +0,0 @@
-import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeLowerText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  TENANCY_MODE_NONE,
-  resolveTenancyProfile
-} from "../shared/tenancyProfile.js";
-import { workspacePendingInvitationsResource } from "../shared/resources/workspacePendingInvitationsResource.js";
-import {
-  mapMembershipSummary,
-  mapWorkspaceSettingsPublic,
-  mapWorkspaceSummary
-} from "./common/formatters/workspaceFormatter.js";
-
-const REQUESTED_WORKSPACE_STATUS_RESOLVED = "resolved";
-const REQUESTED_WORKSPACE_STATUS_NOT_FOUND = "not_found";
-const REQUESTED_WORKSPACE_STATUS_FORBIDDEN = "forbidden";
-const REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED = "unauthenticated";
-
-function normalizePendingInvites(invites) {
-  return workspacePendingInvitationsResource.operations.list.outputValidator.normalize({
-    pendingInvites: invites
-  }).pendingInvites;
-}
-
-function normalizeQueryPayload(value = {}) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value;
-}
-
-function resolveBootstrapWorkspaceSlug({ query = {}, request = null } = {}) {
-  const normalizedQuery = normalizeQueryPayload(query);
-  if (Object.hasOwn(normalizedQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedQuery.workspaceSlug);
-  }
-
-  const normalizedInputQuery = normalizeQueryPayload(request?.input?.query);
-  if (Object.hasOwn(normalizedInputQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedInputQuery.workspaceSlug);
-  }
-
-  const normalizedRequestQuery = normalizeQueryPayload(request?.query);
-  if (Object.hasOwn(normalizedRequestQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedRequestQuery.workspaceSlug);
-  }
-
-  return "";
-}
-
-function normalizeRequestedWorkspaceStatus(value = "") {
-  const normalizedValue = normalizeLowerText(value);
-  if (
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_RESOLVED ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_NOT_FOUND ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_FORBIDDEN ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
-  ) {
-    return normalizedValue;
-  }
-  return "";
-}
-
-function createRequestedWorkspacePayload(workspaceSlug = "", status = "") {
-  const normalizedWorkspaceSlug = normalizeLowerText(workspaceSlug);
-  const normalizedStatus = normalizeRequestedWorkspaceStatus(status);
-  if (!normalizedWorkspaceSlug || !normalizedStatus) {
-    return null;
-  }
-  return {
-    slug: normalizedWorkspaceSlug,
-    status: normalizedStatus
-  };
-}
-
-function resolveRequestedWorkspaceStatusFromError(error) {
-  const statusCode = Number(error?.statusCode || error?.status || 0);
-  if (statusCode === 404) {
-    return REQUESTED_WORKSPACE_STATUS_NOT_FOUND;
-  }
-  if (statusCode === 403) {
-    return REQUESTED_WORKSPACE_STATUS_FORBIDDEN;
-  }
-  if (statusCode === 401) {
-    return REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED;
-  }
-  return "";
-}
-
-function resolveBootstrapTenancyProfile(tenancyProfile = null, appConfig = {}) {
-  const fallback = resolveTenancyProfile(appConfig);
-  return Object.freeze({
-    mode: fallback.mode,
-    workspace: Object.freeze({
-      enabled: fallback.workspace.enabled === true,
-      autoProvision: fallback.workspace.autoProvision === true,
-      allowSelfCreate: fallback.workspace.allowSelfCreate === true,
-      slugPolicy: fallback.workspace.slugPolicy
-    })
-  });
-}
-
-function createWorkspaceBootstrapContributor({
-  workspaceService,
-  workspacePendingInvitationsService,
-  usersRepository,
-  workspaceInvitationsEnabled = false,
-  appConfig = {},
-  tenancyProfile = null
-} = {}) {
-  const contributorId = "users.workspace.bootstrap";
-  const resolvedTenancyProfile = resolveBootstrapTenancyProfile(tenancyProfile, appConfig);
-
-  requireServiceMethod(workspaceService, "listWorkspacesForUser", contributorId, {
-    serviceLabel: "workspaceService"
-  });
-  requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId, {
-    serviceLabel: "workspaceService"
-  });
-  if (workspaceInvitationsEnabled) {
-    requireServiceMethod(workspacePendingInvitationsService, "listPendingInvitesForUser", contributorId, {
-      serviceLabel: "workspacePendingInvitationsService"
-    });
-  }
-  requireServiceMethod(usersRepository, "findById", contributorId, {
-    serviceLabel: "usersRepository"
-  });
-
-  return Object.freeze({
-    contributorId,
-    order: 200,
-    async contribute({ request = null, query = {}, payload = {} } = {}) {
-      const normalizedUserId = normalizeRecordId(
-        payload?.session?.authenticated === true ? payload?.session?.userId : null,
-        { fallback: null }
-      );
-      const normalizedWorkspaceSlug = resolveBootstrapWorkspaceSlug({ query, request });
-      if (!normalizedUserId) {
-        if (!normalizedWorkspaceSlug || resolvedTenancyProfile.mode === TENANCY_MODE_NONE) {
-          return {};
-        }
-
-        return {
-          requestedWorkspace: createRequestedWorkspacePayload(
-            normalizedWorkspaceSlug,
-            REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
-          )
-        };
-      }
-
-      const latestProfile = await usersRepository.findById(normalizedUserId);
-      if (!latestProfile) {
-        return {};
-      }
-
-      const pendingInvites =
-        workspaceInvitationsEnabled
-          ? normalizePendingInvites(
-              await workspacePendingInvitationsService.listPendingInvitesForUser(latestProfile, {
-                context: {
-                  actor: latestProfile
-                }
-              })
-            )
-          : [];
-      const workspaces = await workspaceService.listWorkspacesForUser(latestProfile, { request });
-      let workspaceContext = null;
-      let requestedWorkspace = null;
-      if (normalizedWorkspaceSlug && resolvedTenancyProfile.mode !== TENANCY_MODE_NONE) {
-        try {
-          workspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
-            latestProfile,
-            normalizedWorkspaceSlug,
-            { request }
-          );
-          requestedWorkspace = createRequestedWorkspacePayload(
-            normalizedWorkspaceSlug,
-            REQUESTED_WORKSPACE_STATUS_RESOLVED
-          );
-        } catch (error) {
-          const requestedWorkspaceStatus = resolveRequestedWorkspaceStatusFromError(error);
-          if (!requestedWorkspaceStatus) {
-            throw error;
-          }
-          requestedWorkspace = createRequestedWorkspacePayload(normalizedWorkspaceSlug, requestedWorkspaceStatus);
-        }
-      }
-
-      return {
-        workspaces: [...workspaces],
-        pendingInvites,
-        activeWorkspace: workspaceContext
-          ? mapWorkspaceSummary(workspaceContext.workspace, {
-              roleSid: workspaceContext.membership?.roleSid,
-              status: workspaceContext.membership?.status
-            })
-          : null,
-        membership: mapMembershipSummary(workspaceContext?.membership, workspaceContext?.workspace),
-        requestedWorkspace,
-        permissions: workspaceContext ? [...workspaceContext.permissions] : [],
-        workspaceSettings: workspaceContext
-          ? mapWorkspaceSettingsPublic(workspaceContext.workspaceSettings, {
-              workspaceInvitationsEnabled
-            })
-          : null
-      };
-    }
-  });
-}
-
-export { createWorkspaceBootstrapContributor };

package/src/server/workspaceDirectory/bootWorkspaceDirectoryRoutes.js

@@ -1,133 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { workspaceResource } from "../../shared/resources/workspaceResource.js";
-import { resolveWorkspaceRoutePath } from "../common/support/workspaceRoutePaths.js";
-import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
-import { resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig } from "../support/workspaceActionSurfaces.js";
-
-function bootWorkspaceDirectoryRoutes(app) {
-  if (!app || typeof app.make !== "function" || typeof app.has !== "function") {
-    throw new Error("bootWorkspaceDirectoryRoutes requires application make()/has().");
-  }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
-  const workspaceSelfCreateEnabled = app.has("users.workspace.self-create.enabled")
-    ? app.make("users.workspace.self-create.enabled") === true
-    : false;
-
-  if (workspaceSelfCreateEnabled) {
-    router.register(
-      "POST",
-      "/api/workspaces",
-      {
-        auth: "required",
-        meta: {
-          tags: ["workspace"],
-          summary: "Create a workspace for the authenticated user"
-        },
-        bodyValidator: workspaceResource.operations.create.bodyValidator,
-        responseValidators: withStandardErrorResponses(
-          {
-            200: workspaceResource.operations.create.outputValidator
-          },
-          { includeValidation400: true }
-        )
-      },
-      async function (request, reply) {
-        const body = request.input.body || {};
-        const response = await request.executeAction({
-          actionId: "workspace.workspaces.create",
-          input: {
-            name: body.name,
-            slug: body.slug
-          }
-        });
-        reply.code(200).send(response);
-      }
-    );
-  }
-
-  router.register(
-    "GET",
-    "/api/workspaces",
-    {
-      auth: "required",
-      meta: {
-        tags: ["workspace"],
-        summary: "List workspaces visible to authenticated user"
-      },
-      responseValidators: withStandardErrorResponses({
-        200: workspaceResource.operations.list.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.workspaces.list",
-        input: {}
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    resolveWorkspaceRoutePath("/"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      meta: {
-        tags: ["workspace"],
-        summary: "Get workspace profile by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceResource.operations.view.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.workspaces.read",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    resolveWorkspaceRoutePath("/"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      meta: {
-        tags: ["workspace"],
-        summary: "Update workspace profile by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      bodyValidator: workspaceResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: workspaceResource.operations.patch.outputValidator
-        },
-        { includeValidation400: true }
-      )
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.workspaces.update",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          patch: request.input.body
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { bootWorkspaceDirectoryRoutes };

package/src/server/workspaceDirectory/registerWorkspaceDirectory.js

@@ -1,19 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { workspaceDirectoryActions } from "./workspaceDirectoryActions.js";
-
-function registerWorkspaceDirectory(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerWorkspaceDirectory requires application singleton()/actions().");
-  }
-
-  app.actions(
-    withActionDefaults(workspaceDirectoryActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceService: "users.workspace.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceDirectory };

package/src/server/workspaceDirectory/workspaceDirectoryActions.js

@@ -1,133 +0,0 @@
-import {
-  EMPTY_INPUT_VALIDATOR,
-  resolveRequest
-} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
-import { workspaceResource } from "../../shared/resources/workspaceResource.js";
-import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
-import { resolveActionUser } from "../common/support/resolveActionUser.js";
-
-const workspaceDirectoryActions = Object.freeze([
-  {
-    id: "workspace.workspaces.create",
-    version: 1,
-    kind: "command",
-    channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "enabled",
-    permission: {
-      require: "authenticated"
-    },
-    inputValidator: workspaceResource.operations.create.bodyValidator,
-    outputValidator: workspaceResource.operations.create.outputValidator,
-    idempotency: "none",
-    audit: {
-      actionName: "workspace.workspaces.create"
-    },
-    observability: {},
-    extensions: {
-      assistant: {
-        description: "Create a workspace for the authenticated user."
-      }
-    },
-    async execute(input, context, deps) {
-      return deps.workspaceService.createWorkspaceForAuthenticatedUser(resolveActionUser(context, input), input, {
-        request: resolveRequest(context),
-        context
-      });
-    }
-  },
-  {
-    id: "workspace.workspaces.list",
-    version: 1,
-    kind: "query",
-    channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
-    permission: {
-      require: "authenticated"
-    },
-    inputValidator: EMPTY_INPUT_VALIDATOR,
-    outputValidator: workspaceResource.operations.list.outputValidator,
-    idempotency: "none",
-    audit: {
-      actionName: "workspace.workspaces.list"
-    },
-    observability: {},
-    async execute(input, context, deps) {
-      return {
-        items: await deps.workspaceService.listWorkspacesForAuthenticatedUser(resolveActionUser(context, input), {
-          request: resolveRequest(context),
-          context
-        }),
-        nextCursor: null
-      };
-    }
-  },
-  {
-    id: "workspace.workspaces.read",
-    version: 1,
-    kind: "query",
-    channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
-    permission: {
-      require: "any",
-      permissions: ["workspace.settings.view", "workspace.settings.update"]
-    },
-    inputValidator: workspaceSlugParamsValidator,
-    outputValidator: workspaceResource.operations.view.outputValidator,
-    idempotency: "none",
-    audit: {
-      actionName: "workspace.workspaces.read"
-    },
-    observability: {},
-    async execute(input, context, deps) {
-      return deps.workspaceService.getWorkspaceForAuthenticatedUser(
-        resolveActionUser(context, input),
-        input.workspaceSlug,
-        {
-          request: resolveRequest(context),
-          context
-        }
-      );
-    }
-  },
-  {
-    id: "workspace.workspaces.update",
-    version: 1,
-    kind: "command",
-    channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
-    permission: {
-      require: "all",
-      permissions: ["workspace.settings.update"]
-    },
-    inputValidator: [
-      workspaceSlugParamsValidator,
-      {
-        patch: workspaceResource.operations.patch.bodyValidator
-      }
-    ],
-    outputValidator: workspaceResource.operations.patch.outputValidator,
-    idempotency: "optional",
-    audit: {
-      actionName: "workspace.workspaces.update"
-    },
-    observability: {},
-    extensions: {
-      assistant: {
-        description: "Update workspace profile fields."
-      }
-    },
-    async execute(input, context, deps) {
-      return deps.workspaceService.updateWorkspaceForAuthenticatedUser(
-        resolveActionUser(context, input),
-        input.workspaceSlug,
-        input.patch,
-        {
-          request: resolveRequest(context),
-          context
-        }
-      );
-    }
-  }
-]);
-
-export { workspaceDirectoryActions };