@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/src/shared/resources/workspaceMembersResource.js

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

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -0,0 +1,82 @@
+import { Type } from "@fastify/type-provider-typebox";
+import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { createOperationMessages } from "../operationMessages.js";
+import { normalizeObjectInput, recordIdSchema } from "@jskit-ai/kernel/shared/validators";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizePendingInvite(invite) {
+  const id = normalizeRecordId(invite?.id, { fallback: null });
+  const workspaceId = normalizeRecordId(invite?.workspaceId, { fallback: null });
+  const tokenHash = normalizeText(invite?.tokenHash);
+
+  if (!id || !workspaceId || !tokenHash) {
+    return null;
+  }
+
+  return {
+    id,
+    workspaceId,
+    workspaceSlug: normalizeText(invite?.workspaceSlug),
+    workspaceName: normalizeText(invite?.workspaceName || invite?.workspaceSlug),
+    workspaceAvatarUrl: normalizeText(invite?.workspaceAvatarUrl),
+    roleSid: normalizeLowerText(invite?.roleSid || "member") || "member",
+    status: normalizeLowerText(invite?.status || "pending") || "pending",
+    expiresAt: invite?.expiresAt || null,
+    token: encodeInviteTokenHash(tokenHash)
+  };
+}
+
+function normalizePendingInviteList(invites) {
+  return (Array.isArray(invites) ? invites : []).map((invite) => normalizePendingInvite(invite)).filter(Boolean);
+}
+
+const pendingInviteRecordValidator = Object.freeze({
+  schema: Type.Object(
+    {
+      id: recordIdSchema,
+      workspaceId: recordIdSchema,
+      workspaceSlug: Type.String({ minLength: 1 }),
+      workspaceName: Type.String({ minLength: 1 }),
+      workspaceAvatarUrl: Type.String(),
+      roleSid: Type.String({ minLength: 1 }),
+      status: Type.String({ minLength: 1 }),
+      expiresAt: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+      token: Type.String({ minLength: 1 })
+    },
+    { additionalProperties: false }
+  ),
+  normalize: normalizePendingInvite
+});
+
+const pendingInvitationsListOutputValidator = Object.freeze({
+  schema: Type.Object(
+    {
+      pendingInvites: Type.Array(pendingInviteRecordValidator.schema)
+    },
+    { additionalProperties: false }
+  ),
+  normalize(payload = {}) {
+    const source = normalizeObjectInput(payload);
+
+    return {
+      pendingInvites: normalizePendingInviteList(source.pendingInvites)
+    };
+  }
+});
+
+const WORKSPACE_PENDING_INVITATIONS_MESSAGES = createOperationMessages();
+
+const workspacePendingInvitationsResource = Object.freeze({
+  resource: "workspacePendingInvitations",
+  messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
+  operations: Object.freeze({
+    list: Object.freeze({
+      method: "GET",
+      messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
+      outputValidator: pendingInvitationsListOutputValidator
+    })
+  })
+});
+
+export { workspacePendingInvitationsResource };

package/src/shared/resources/workspaceResource.js

@@ -0,0 +1,176 @@
+import { Type } from "typebox";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import {
+  normalizeObjectInput,
+  createCursorListValidator,
+  recordIdSchema,
+  recordIdInputSchema
+} from "@jskit-ai/kernel/shared/validators";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizeWorkspaceAvatarUrl(value) {
+  const avatarUrl = normalizeText(value);
+  if (!avatarUrl) {
+    return "";
+  }
+  if (!avatarUrl.startsWith("http://") && !avatarUrl.startsWith("https://")) {
+    return null;
+  }
+  try {
+    return new URL(avatarUrl).toString();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeWorkspaceInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "slug")) {
+    normalized.slug = normalizeLowerText(source.slug);
+  }
+  if (Object.hasOwn(source, "name")) {
+    normalized.name = normalizeText(source.name);
+  }
+  if (Object.hasOwn(source, "ownerUserId")) {
+    normalized.ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: "" });
+  }
+  if (Object.hasOwn(source, "avatarUrl")) {
+    normalized.avatarUrl = normalizeWorkspaceAvatarUrl(source.avatarUrl);
+  }
+  if (Object.hasOwn(source, "isPersonal")) {
+    normalized.isPersonal = source.isPersonal === true;
+  }
+
+  return normalized;
+}
+
+function normalizeWorkspaceOutput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: normalizeRecordId(source.id, { fallback: "" }),
+    slug: normalizeLowerText(source.slug),
+    name: normalizeText(source.name),
+    ownerUserId: normalizeRecordId(source.ownerUserId, { fallback: "" }),
+    avatarUrl: normalizeText(source.avatarUrl)
+  };
+}
+
+function normalizeWorkspaceListItemOutput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: normalizeRecordId(source.id, { fallback: "" }),
+    slug: normalizeLowerText(source.slug),
+    name: normalizeText(source.name),
+    avatarUrl: normalizeText(source.avatarUrl),
+    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
+    isAccessible: source.isAccessible !== false
+  };
+}
+
+const responseRecordSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    slug: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1, maxLength: 160 }),
+    ownerUserId: recordIdSchema,
+    avatarUrl: Type.String()
+  },
+  { additionalProperties: false }
+);
+
+const listItemSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    slug: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1, maxLength: 160 }),
+    avatarUrl: Type.String(),
+    roleSid: Type.String({ minLength: 1 }),
+    isAccessible: Type.Boolean()
+  },
+  { additionalProperties: false }
+);
+
+const createRequestBodySchema = Type.Object(
+  {
+    name: Type.String({ minLength: 1, maxLength: 160 }),
+    slug: Type.Optional(Type.String({ minLength: 1, maxLength: 120 })),
+    ownerUserId: Type.Optional(recordIdInputSchema)
+  },
+  { additionalProperties: false }
+);
+
+const patchRequestBodySchema = Type.Object(
+  {
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
+    avatarUrl: Type.Optional(
+      Type.String({
+        pattern: "^(https?://.+)?$",
+        messages: {
+          pattern: "Workspace avatar URL must be a valid absolute URL (http:// or https://).",
+          default: "Workspace avatar URL must be a valid absolute URL (http:// or https://)."
+        }
+      })
+    )
+  },
+  { additionalProperties: false }
+);
+
+const responseRecordValidator = Object.freeze({
+  schema: responseRecordSchema,
+  normalize: normalizeWorkspaceOutput
+});
+
+const workspaceSummaryOutputValidator = Object.freeze({
+  schema: listItemSchema,
+  normalize: normalizeWorkspaceListItemOutput
+});
+
+const resource = {
+  resource: "workspace",
+  messages: {
+    validation: "Fix invalid workspace values and try again.",
+    saveSuccess: "Workspace updated.",
+    saveError: "Unable to update workspace.",
+    apiValidation: "Validation failed."
+  },
+  operations: {
+    view: {
+      method: "GET",
+      outputValidator: responseRecordValidator
+    },
+    list: {
+      method: "GET",
+      outputValidator: createCursorListValidator(workspaceSummaryOutputValidator)
+    },
+    create: {
+      method: "POST",
+      bodyValidator: {
+        schema: createRequestBodySchema,
+        normalize: normalizeWorkspaceInput
+      },
+      outputValidator: responseRecordValidator
+    },
+    replace: {
+      method: "PUT",
+      bodyValidator: {
+        schema: createRequestBodySchema,
+        normalize: normalizeWorkspaceInput
+      },
+      outputValidator: responseRecordValidator
+    },
+    patch: {
+      method: "PATCH",
+      bodyValidator: {
+        schema: patchRequestBodySchema,
+        normalize: normalizeWorkspaceInput
+      },
+      outputValidator: responseRecordValidator
+    }
+  }
+};
+
+export { resource as workspaceResource };

package/src/shared/resources/workspaceSettingsFields.js

@@ -0,0 +1,59 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
+
+const workspaceSettingsFields = resolveGlobalArrayRegistry("jskit.workspaces-core.workspaceSettingsFields");
+
+function defineField(field = {}) {
+  const key = normalizeText(field.key);
+  if (!key) {
+    throw new TypeError("workspaceSettingsFields.defineField requires field.key.");
+  }
+  if (workspaceSettingsFields.some((entry) => entry.key === key)) {
+    throw new Error(`workspaceSettingsFields.defineField duplicate key: ${key}`);
+  }
+  if (!field.inputSchema || typeof field.inputSchema !== "object") {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires inputSchema.`);
+  }
+  if (!field.outputSchema || typeof field.outputSchema !== "object") {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires outputSchema.`);
+  }
+  const dbColumn = normalizeText(field.dbColumn);
+  if (!dbColumn) {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires dbColumn.`);
+  }
+  if (typeof field.normalizeInput !== "function") {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires normalizeInput.`);
+  }
+  if (typeof field.normalizeOutput !== "function") {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires normalizeOutput.`);
+  }
+  if (typeof field.resolveDefault !== "function") {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires resolveDefault.`);
+  }
+
+  workspaceSettingsFields.push({
+    key,
+    dbColumn,
+    required: field.required !== false,
+    inputSchema: field.inputSchema,
+    outputSchema: field.outputSchema,
+    normalizeInput: field.normalizeInput,
+    normalizeOutput: field.normalizeOutput,
+    resolveDefault: field.resolveDefault
+  });
+}
+
+function resetWorkspaceSettingsFields() {
+  workspaceSettingsFields.splice(0, workspaceSettingsFields.length);
+}
+
+function resolveWorkspaceSettingsFieldKeys() {
+  return workspaceSettingsFields.map((field) => field.key);
+}
+
+export {
+  defineField,
+  resetWorkspaceSettingsFields,
+  resolveWorkspaceSettingsFieldKeys,
+  workspaceSettingsFields
+};