@jskit-ai/users-core 0.1.47 → 0.1.49

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

package/src/server/workspaceMembers/bootWorkspaceMembers.js

@@ -1,236 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
-import { resolveWorkspaceRoutePath } from "../common/support/workspaceRoutePaths.js";
-import {
-  routeParamsValidator,
-  workspaceSlugParamsValidator
-} from "../common/validators/routeParamsValidator.js";
-import { resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig } from "../support/workspaceActionSurfaces.js";
-
-function bootWorkspaceMembers(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspaceMembers requires application make().");
-  }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = typeof app.has === "function" && app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceInvitationsEnabled =
-    typeof app.has === "function" && app.has("users.workspace.invitations.enabled")
-      ? app.make("users.workspace.invitations.enabled") === true
-      : false;
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
-
-  router.register(
-    "GET",
-    resolveWorkspaceRoutePath("/roles"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      contextPolicy: "required",
-      meta: {
-        tags: ["workspace"],
-        summary: "Get workspace role catalog by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceMembersResource.operations.rolesList.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.roles.list",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    resolveWorkspaceRoutePath("/members"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      contextPolicy: "required",
-      meta: {
-        tags: ["workspace"],
-        summary: "List members by workspace slug"
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceMembersResource.operations.membersList.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.members.list",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    resolveWorkspaceRoutePath("/members/:memberUserId/role"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      contextPolicy: "required",
-      meta: {
-        tags: ["workspace"],
-        summary: "Update workspace member role by workspace slug"
-      },
-      paramsValidator: routeParamsValidator,
-      bodyValidator: workspaceMembersResource.operations.updateMemberRole.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: workspaceMembersResource.operations.updateMemberRole.outputValidator
-        },
-        { includeValidation400: true }
-      )
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.member.role.update",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          memberUserId: request.input.params.memberUserId,
-          roleSid: request.input.body.roleSid
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "DELETE",
-    resolveWorkspaceRoutePath("/members/:memberUserId"),
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility: "workspace",
-      contextPolicy: "required",
-      meta: {
-        tags: ["workspace"],
-        summary: "Remove workspace member by workspace slug"
-      },
-      paramsValidator: routeParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceMembersResource.operations.removeMember.outputValidator
-      })
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "workspace.member.remove",
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          memberUserId: request.input.params.memberUserId
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  if (workspaceInvitationsEnabled) {
-    router.register(
-      "GET",
-      resolveWorkspaceRoutePath("/invites"),
-      {
-        auth: "required",
-        surface: workspaceRouteSurfaceId,
-        visibility: "workspace",
-        contextPolicy: "required",
-        meta: {
-          tags: ["workspace"],
-          summary: "List workspace invites by workspace slug"
-        },
-        paramsValidator: workspaceSlugParamsValidator,
-        responseValidators: withStandardErrorResponses({
-          200: workspaceMembersResource.operations.invitesList.outputValidator
-        })
-      },
-      async function (request, reply) {
-        const response = await request.executeAction({
-          actionId: "workspace.invites.list",
-          input: {
-            workspaceSlug: request.input.params.workspaceSlug
-          }
-        });
-        reply.code(200).send(response);
-      }
-    );
-
-    router.register(
-      "POST",
-      resolveWorkspaceRoutePath("/invites"),
-      {
-        auth: "required",
-        surface: workspaceRouteSurfaceId,
-        visibility: "workspace",
-        contextPolicy: "required",
-        meta: {
-          tags: ["workspace"],
-          summary: "Create workspace invite by workspace slug"
-        },
-        paramsValidator: workspaceSlugParamsValidator,
-        bodyValidator: workspaceMembersResource.operations.createInvite.bodyValidator,
-        responseValidators: withStandardErrorResponses(
-          {
-            200: workspaceMembersResource.operations.createInvite.outputValidator
-          },
-          { includeValidation400: true }
-        )
-      },
-      async function (request, reply) {
-        const response = await request.executeAction({
-          actionId: "workspace.invite.create",
-          input: {
-            workspaceSlug: request.input.params.workspaceSlug,
-            email: request.input.body.email,
-            roleSid: request.input.body.roleSid
-          }
-        });
-        reply.code(200).send(response);
-      }
-    );
-
-    router.register(
-      "DELETE",
-      resolveWorkspaceRoutePath("/invites/:inviteId"),
-      {
-        auth: "required",
-        surface: workspaceRouteSurfaceId,
-        visibility: "workspace",
-        contextPolicy: "required",
-        meta: {
-          tags: ["workspace"],
-          summary: "Revoke workspace invite by workspace slug"
-        },
-        paramsValidator: routeParamsValidator,
-        responseValidators: withStandardErrorResponses({
-          200: workspaceMembersResource.operations.revokeInvite.outputValidator
-        })
-      },
-      async function (request, reply) {
-        const response = await request.executeAction({
-          actionId: "workspace.invite.revoke",
-          input: {
-            workspaceSlug: request.input.params.workspaceSlug,
-            inviteId: request.input.params.inviteId
-          }
-        });
-        reply.code(200).send(response);
-      }
-    );
-  }
-}
-
-export { bootWorkspaceMembers };

package/src/server/workspaceMembers/registerWorkspaceMembers.js

@@ -1,108 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { normalizeDbRecordId } from "@jskit-ai/database-runtime/shared";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { deepFreeze } from "../common/support/deepFreeze.js";
-import { createService as createWorkspaceMembersService } from "./workspaceMembersService.js";
-import { workspaceMembersActions } from "./workspaceMembersActions.js";
-import { createWorkspaceRoleCatalog } from "../../shared/roles.js";
-import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
-
-
-function resolveWorkspaceMembersInviteExpiresInMs(appConfig = {}) {
-  const inviteExpiresInMs = Number(appConfig?.workspaceMembers?.defaults?.inviteExpiresInMs);
-  if (!Number.isInteger(inviteExpiresInMs) || inviteExpiresInMs < 1) {
-    throw new TypeError("users.core requires appConfig.workspaceMembers.defaults.inviteExpiresInMs.");
-  }
-
-  return inviteExpiresInMs;
-}
-
-const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
-  preset: "event_scope",
-  async userQuery({ knex, event } = {}) {
-    if (typeof knex !== "function") {
-      return [];
-    }
-
-    const inviteId = normalizeRecordId(event?.entityId, { fallback: null });
-    if (!inviteId) {
-      return [];
-    }
-
-    const row = await knex("workspace_invites as wi")
-      .join("users as up", "up.email", "wi.email")
-      .where("wi.id", inviteId)
-      .first("up.id as user_id");
-
-    const userId = normalizeDbRecordId(row?.user_id, { fallback: null });
-    if (!userId) {
-      return [];
-    }
-
-    return [
-      {
-        userId
-      }
-    ];
-  }
-});
-
-function registerWorkspaceMembers(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerWorkspaceMembers requires application singleton()/service()/actions().");
-  }
-
-  app.service(
-    "users.workspace.members.service",
-    (scope) => {
-      const appConfig = resolveAppConfig(scope);
-      return createWorkspaceMembersService({
-        workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository"),
-        workspaceInvitesRepository: scope.make("workspaceInvitesRepository"),
-        inviteExpiresInMs: resolveWorkspaceMembersInviteExpiresInMs(appConfig),
-        roleCatalog: createWorkspaceRoleCatalog(appConfig),
-        workspaceInvitationsEnabled: scope.make("users.workspace.invitations.enabled") === true
-      });
-    },
-    {
-      events: deepFreeze({
-        updateMemberRole: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "member",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.members.changed"
-        }),
-        removeMember: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "member",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.members.changed"
-        }),
-        createInvite: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "invite",
-          workspaceOperation: "created",
-          workspaceRealtimeEvent: "workspace.invites.changed",
-          bootstrapEntityId: ({ result }) => result?.createdInviteId,
-          bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
-        }),
-        revokeInvite: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "invite",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.invites.changed",
-          bootstrapEntityId: ({ result }) => result?.revokedInviteId,
-          bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
-        })
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(workspaceMembersActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceMembersService: "users.workspace.members.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceMembers };