@jskit-ai/users-core 0.1.48 → 0.1.50

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/workspaceMembersResource.js

@@ -1,354 +0,0 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  recordIdSchema,
-  recordIdInputSchema,
-  nullableRecordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { createOperationMessages } from "../operationMessages.js";
-import { createWorkspaceRoleCatalog, OWNER_ROLE_ID } from "../roles.js";
-
-const workspaceSummaryOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1 }),
-    ownerUserId: recordIdSchema,
-    avatarUrl: Type.String()
-  },
-  { additionalProperties: false }
-);
-
-const memberSummaryOutputSchema = Type.Object(
-  {
-    userId: recordIdSchema,
-    roleSid: Type.String({ minLength: 1 }),
-    status: Type.String({ minLength: 1 }),
-    displayName: Type.String(),
-    email: Type.String({ minLength: 1 }),
-    isOwner: Type.Boolean()
-  },
-  { additionalProperties: false }
-);
-
-const inviteSummaryOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    email: Type.String({ minLength: 3, format: "email" }),
-    roleSid: Type.String({ minLength: 1 }),
-    status: Type.String({ minLength: 1 }),
-    expiresAt: Type.String({ minLength: 1 }),
-    invitedByUserId: nullableRecordIdSchema
-  },
-  { additionalProperties: false }
-);
-
-function normalizeWorkspaceAdminSummary(workspace) {
-  const source = normalizeObjectInput(workspace);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeText(source.slug),
-    name: normalizeText(source.name),
-    ownerUserId: normalizeRecordId(source.ownerUserId, { fallback: "" }),
-    avatarUrl: normalizeText(source.avatarUrl)
-  };
-}
-
-function normalizeMemberSummary(member, workspace) {
-  const source = normalizeObjectInput(member);
-  const userId = normalizeRecordId(source.userId, { fallback: "" });
-
-  return {
-    userId,
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    status: normalizeLowerText(source.status || "active") || "active",
-    displayName: normalizeText(source.displayName),
-    email: normalizeLowerText(source.email),
-    isOwner: userId === workspace.ownerUserId || normalizeLowerText(source.roleSid) === OWNER_ROLE_ID
-  };
-}
-
-function normalizeInviteSummary(invite) {
-  const source = normalizeObjectInput(invite);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    email: normalizeLowerText(source.email),
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    status: normalizeLowerText(source.status || "pending") || "pending",
-    expiresAt: source.expiresAt,
-    invitedByUserId: source.invitedByUserId == null ? null : normalizeRecordId(source.invitedByUserId, { fallback: null })
-  };
-}
-
-function normalizeWorkspaceOutputEnvelope(
-  payload = {},
-  { itemsKey, normalizeItem, includeInviteTokenPreview = false } = {}
-) {
-  const source = normalizeObjectInput(payload);
-  const workspace = normalizeWorkspaceAdminSummary(source.workspace);
-  const items = Array.isArray(source[itemsKey]) ? source[itemsKey] : [];
-  const roleCatalog = normalizeObjectInput(source.roleCatalog);
-  const hasRoleCatalog =
-    Array.isArray(roleCatalog.roles) &&
-    roleCatalog.roles.length > 0 &&
-    Array.isArray(roleCatalog.assignableRoleIds);
-  const normalized = {
-    workspace,
-    [itemsKey]: items.map((item) => normalizeItem(item, workspace)),
-    roleCatalog: hasRoleCatalog ? roleCatalog : createWorkspaceRoleCatalog()
-  };
-
-  if (includeInviteTokenPreview && Object.hasOwn(source, "inviteTokenPreview")) {
-    normalized.inviteTokenPreview = normalizeText(source.inviteTokenPreview);
-  }
-
-  return normalized;
-}
-
-function normalizeWorkspaceMembersOutput(payload = {}) {
-  return normalizeWorkspaceOutputEnvelope(payload, {
-    itemsKey: "members",
-    normalizeItem: normalizeMemberSummary
-  });
-}
-
-function normalizeWorkspaceInvitesOutput(payload = {}) {
-  return normalizeWorkspaceOutputEnvelope(payload, {
-    itemsKey: "invites",
-    normalizeItem: normalizeInviteSummary,
-    includeInviteTokenPreview: true
-  });
-}
-
-const workspaceRoleCatalogOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      collaborationEnabled: Type.Boolean(),
-      defaultInviteRole: Type.String(),
-      roles: Type.Array(Type.Object({}, { additionalProperties: true })),
-      assignableRoleIds: Type.Array(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: true }
-  )
-});
-
-const workspaceMembersOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspace: workspaceSummaryOutputSchema,
-      members: Type.Array(memberSummaryOutputSchema),
-      roleCatalog: workspaceRoleCatalogOutputValidator.schema
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceMembersOutput
-});
-
-const workspaceInvitesOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspace: workspaceSummaryOutputSchema,
-      invites: Type.Array(inviteSummaryOutputSchema),
-      roleCatalog: workspaceRoleCatalogOutputValidator.schema,
-      inviteTokenPreview: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceInvitesOutput
-});
-
-const updateMemberRoleBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      roleSid: normalizeLowerText(source.roleSid)
-    };
-  }
-});
-
-const updateMemberRoleInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      memberUserId: recordIdInputSchema,
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      memberUserId: normalizeRecordId(source.memberUserId, { fallback: "" }),
-      roleSid: normalizeLowerText(source.roleSid)
-    };
-  }
-});
-
-const removeMemberInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      memberUserId: recordIdInputSchema
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      memberUserId: normalizeRecordId(source.memberUserId, { fallback: "" })
-    };
-  }
-});
-
-const createInviteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: Type.String({ minLength: 3, format: "email" }),
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      email: normalizeLowerText(source.email),
-      roleSid: normalizeLowerText(source.roleSid || "member") || "member"
-    };
-  }
-});
-
-const revokeInviteInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      inviteId: recordIdInputSchema
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      inviteId: normalizeRecordId(source.inviteId, { fallback: "" })
-    };
-  }
-});
-
-const redeemInviteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      token: Type.String({
-        minLength: 1,
-        messages: {
-          required: "Invite token is required.",
-          minLength: "Invite token is required.",
-          default: "Invite token is invalid."
-        }
-      }),
-      decision: Type.Union([Type.Literal("accept"), Type.Literal("refuse")], {
-        messages: {
-          required: "Decision is required.",
-          default: "Decision must be accept or refuse."
-        }
-      })
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
-    }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      token: normalizeText(source.token),
-      decision: normalizeLowerText(source.decision)
-    };
-  }
-});
-
-const redeemInviteOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      decision: Type.Union([Type.Literal("accepted"), Type.Literal("refused")])
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      decision: normalizeLowerText(source.decision)
-    };
-  }
-});
-
-const WORKSPACE_MEMBERS_MESSAGES = createOperationMessages();
-
-const workspaceMembersResource = Object.freeze({
-  resource: "workspaceMembers",
-  messages: WORKSPACE_MEMBERS_MESSAGES,
-  operations: Object.freeze({
-    rolesList: Object.freeze({
-      method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceRoleCatalogOutputValidator
-    }),
-    membersList: Object.freeze({
-      method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    updateMemberRole: Object.freeze({
-      method: "PATCH",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: updateMemberRoleBodyValidator,
-      inputValidator: updateMemberRoleInputValidator,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    removeMember: Object.freeze({
-      method: "DELETE",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      inputValidator: removeMemberInputValidator,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    invitesList: Object.freeze({
-      method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    createInvite: Object.freeze({
-      method: "POST",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: createInviteBodyValidator,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    revokeInvite: Object.freeze({
-      method: "DELETE",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      inputValidator: revokeInviteInputValidator,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    redeemInvite: Object.freeze({
-      method: "POST",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: redeemInviteBodyValidator,
-      outputValidator: redeemInviteOutputValidator
-    })
-  })
-});
-
-export { workspaceMembersResource };