@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/src/server/workspaceBootstrapContributor.js

@@ -0,0 +1,233 @@
+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 inheritedAppState = payload?.app && typeof payload.app === "object" ? payload.app : {};
+      const inheritedFeatures =
+        inheritedAppState.features && typeof inheritedAppState.features === "object" ? inheritedAppState.features : {};
+      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 {
+          tenancy: resolvedTenancyProfile,
+          app: {
+            ...inheritedAppState,
+            features: {
+              ...inheritedFeatures,
+              workspaceSwitching: normalizeLowerText(resolvedTenancyProfile.mode) !== TENANCY_MODE_NONE,
+              workspaceInvites: workspaceInvitationsEnabled === true
+            }
+          },
+          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 {
+        tenancy: resolvedTenancyProfile,
+        app: {
+          ...inheritedAppState,
+          features: {
+            ...inheritedFeatures,
+            workspaceSwitching: normalizeLowerText(resolvedTenancyProfile.mode) !== TENANCY_MODE_NONE,
+            workspaceInvites: workspaceInvitationsEnabled === true
+          }
+        },
+        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

@@ -0,0 +1,133 @@
+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("workspaces.self-create.enabled")
+    ? app.make("workspaces.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

@@ -0,0 +1,19 @@
+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: "workspaces.service"
+      }
+    })
+  );
+}
+
+export { registerWorkspaceDirectory };

package/src/server/workspaceDirectory/workspaceDirectoryActions.js

@@ -0,0 +1,133 @@
+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 };