@jskit-ai/workspaces-core 0.1.81 → 0.1.83

package/src/shared/resources/workspaceMembersResource.js

@@ -87,6 +87,30 @@ const workspaceInviteCreateOutputSchema = createSchema({
     required: true,
     minLength: 1
   },
+  inviteUrl: {
+    type: "string",
+    required: true,
+    minLength: 1
+  },
+  inviteDelivery: {
+    type: "object",
+    required: true,
+    schema: createSchema({
+      status: {
+        type: "string",
+        required: true,
+        enum: ["sent", "failed", "mailer_unconfigured"]
+      },
+      message: {
+        type: "string",
+        required: true
+      },
+      providerMessageId: {
+        type: "string",
+        required: true
+      }
+    })
+  },
   createdInviteId: {
     type: "string",
     required: true,

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -3,6 +3,45 @@ import { createSchema } from "json-rest-schema";
 import { defineResource } from "@jskit-ai/resource-core/shared/resource";
 import { createOperationMessages } from "../operationMessages.js";
 
+const invitationTokenQuerySchema = createSchema({
+  token: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    messages: {
+      required: "Invite token is required.",
+      minLength: "Invite token is required.",
+      default: "Invite token is invalid."
+    }
+  }
+});
+
+const invitationWorkspaceSummarySchema = createSchema({
+  id: { type: "string", required: true },
+  slug: { type: "string", required: true },
+  name: { type: "string", required: true },
+  avatarUrl: { type: "string", required: true }
+});
+
+const invitationResolveOutputSchema = createSchema({
+  id: { type: "string", required: true },
+  token: { type: "string", required: true, minLength: 1 },
+  status: {
+    type: "string",
+    required: true,
+    enum: ["pending", "expired", "accepted", "revoked", "not_found"]
+  },
+  email: { type: "string", required: true },
+  maskedEmail: { type: "string", required: true },
+  roleSid: { type: "string", required: true },
+  expiresAt: { type: "string", required: false, nullable: true, minLength: 1 },
+  workspace: {
+    type: "object",
+    required: true,
+    schema: invitationWorkspaceSummarySchema
+  }
+});
+
 const pendingInvitationsListOutputSchema = createSchema({
   pendingInvites: {
     type: "array",
@@ -25,6 +64,11 @@ const workspacePendingInvitationsResource = defineResource({
   namespace: "workspacePendingInvitations",
   messages: createOperationMessages(),
   operations: {
+    resolve: {
+      method: "GET",
+      query: invitationTokenQuerySchema,
+      output: invitationResolveOutputSchema
+    },
     list: {
       method: "GET",
       output: pendingInvitationsListOutputSchema

package/templates/packages/main/src/server/email/workspaceInviteEmail.js

@@ -0,0 +1,23 @@
+function renderWorkspaceInviteEmail({
+  inviteUrl = "",
+  workspace = {},
+  inviter = null,
+  roleSid = "member",
+  expiresAt = ""
+} = {}) {
+  const workspaceName = String(workspace?.name || workspace?.slug || "the workspace").trim() || "the workspace";
+  const inviterName = String(inviter?.displayName || inviter?.email || "").trim();
+  const roleName = String(roleSid || "member").trim() || "member";
+  const intro = inviterName
+    ? `${inviterName} invited you to join ${workspaceName} as ${roleName}.`
+    : `You have been invited to join ${workspaceName} as ${roleName}.`;
+  const expiryText = expiresAt ? `This invitation expires at ${expiresAt}.` : "";
+
+  return {
+    subject: `You're invited to ${workspaceName}`,
+    text: [intro, expiryText, "Open this link to accept the invitation:", inviteUrl].filter(Boolean).join("\n\n"),
+    html: null
+  };
+}
+
+export { renderWorkspaceInviteEmail };

package/test/packageDescriptor.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import descriptor from "../package.descriptor.mjs";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_DIR = path.resolve(TEST_DIRECTORY, "..");
+
+function findRoute(method, routePath) {
+  const routes = descriptor?.metadata?.server?.routes;
+  return Array.isArray(routes)
+    ? routes.find((entry) => entry?.method === method && entry?.path === routePath) || null
+    : null;
+}
+
+function findFileMutation(id) {
+  const fileMutations = descriptor?.mutations?.files;
+  return Array.isArray(fileMutations)
+    ? fileMutations.find((entry) => String(entry?.id || "").trim() === id) || null
+    : null;
+}
+
+function findSourceMutation(id) {
+  const sourceMutations = descriptor?.mutations?.source;
+  return Array.isArray(sourceMutations)
+    ? sourceMutations.find((entry) => String(entry?.id || "").trim() === id) || null
+    : null;
+}
+
+test("workspaces-core descriptor advertises public invite resolution route metadata", () => {
+  assert.deepEqual(findRoute("GET", "/api/workspace/invitations/resolve"), {
+    method: "GET",
+    path: "/api/workspace/invitations/resolve",
+    summary: "Resolve safe public workspace invitation metadata."
+  });
+});
+
+test("workspaces-core installs an app-owned editable workspace invite email template", async () => {
+  const source = await readFile(
+    path.join(PACKAGE_DIR, "templates", "packages", "main", "src", "server", "email", "workspaceInviteEmail.js"),
+    "utf8"
+  );
+
+  assert.match(source, /function renderWorkspaceInviteEmail/);
+  assert.match(source, /export \{ renderWorkspaceInviteEmail \}/);
+  assert.match(source, /inviteUrl/);
+  assert.deepEqual(findFileMutation("workspaces-core-main-workspace-invite-email-template"), {
+    from: "templates/packages/main/src/server/email/workspaceInviteEmail.js",
+    to: "packages/main/src/server/email/workspaceInviteEmail.js",
+    preserveOnRemove: true,
+    reason: "Install app-owned editable workspace invite email template.",
+    category: "workspaces-core",
+    id: "workspaces-core-main-workspace-invite-email-template"
+  });
+  assert.deepEqual(findSourceMutation("workspaces-core-server-config-workspace-invite-email-import"), {
+    op: "ensure-import",
+    file: "config/server.js",
+    namedImports: ["renderWorkspaceInviteEmail"],
+    from: "../packages/main/src/server/email/workspaceInviteEmail.js",
+    reason: "Load app-owned workspace invite email renderer from packages/main.",
+    category: "workspaces-core",
+    id: "workspaces-core-server-config-workspace-invite-email-import"
+  });
+  assert.deepEqual(findSourceMutation("workspaces-core-server-config-workspace-invite-email-template"), {
+    op: "ensure-assignment",
+    file: "config/server.js",
+    target: "config.workspaceInviteEmailTemplate",
+    value: "renderWorkspaceInviteEmail",
+    reason: "Bind app-owned workspace invite email renderer into server config.",
+    category: "workspaces-core",
+    id: "workspaces-core-server-config-workspace-invite-email-template"
+  });
+});

package/test/registerWorkspaceMembers.test.js

@@ -0,0 +1,140 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
+
+function createAppDouble() {
+  const serviceCalls = [];
+
+  return {
+    serviceCalls,
+    app: {
+      singleton() {
+        return this;
+      },
+      service(token, factory, metadata) {
+        serviceCalls.push({
+          token,
+          factory,
+          metadata
+        });
+        return this;
+      },
+      actions() {
+        return this;
+      }
+    }
+  };
+}
+
+function createScopeDouble(bindings = {}) {
+  return {
+    has(token) {
+      return Object.hasOwn(bindings, token);
+    },
+    make(token) {
+      if (!Object.hasOwn(bindings, token)) {
+        throw new Error(`Missing test binding: ${token}`);
+      }
+      const binding = bindings[token];
+      return typeof binding === "function" && token !== "appConfig" ? binding(this) : binding;
+    }
+  };
+}
+
+test("registerWorkspaceMembers uses app-owned workspace invite email template from appConfig", async () => {
+  const templateCalls = [];
+  const mailerCalls = [];
+  const fixture = createAppDouble();
+  registerWorkspaceMembers(fixture.app);
+  const serviceCall = fixture.serviceCalls.find((entry) => entry.token === "workspaces.members.service");
+
+  const service = serviceCall.factory(createScopeDouble({
+    appConfig: {
+      workspaceMembers: {
+        defaults: {
+          inviteExpiresInMs: 60_000
+        }
+      },
+      roleCatalog: {
+        workspace: {
+          defaultInviteRole: "member"
+        },
+        roles: {
+          owner: {
+            assignable: false,
+            permissions: ["*"]
+          },
+          member: {
+            assignable: true,
+            permissions: ["workspace.members.view"]
+          }
+        }
+      },
+      workspaceInviteEmailTemplate(payload) {
+        templateCalls.push(payload);
+        return {
+          subject: "Custom invite",
+          text: payload.inviteUrl,
+          html: null
+        };
+      }
+    },
+    "jskit.env": {
+      APP_PUBLIC_URL: "https://app.example.test"
+    },
+    "workspaces.invitations.enabled": true,
+    "workspaces.invite.mailer": {
+      async sendWorkspaceInvite(payload) {
+        mailerCalls.push(payload);
+        return {
+          status: "sent",
+          message: "sent",
+          providerMessageId: "msg-custom"
+        };
+      }
+    },
+    "internal.repository.workspace-memberships": {
+      async listActiveByWorkspaceId() {
+        return [];
+      }
+    },
+    "internal.repository.workspace-invites": {
+      async listPendingByWorkspaceIdWithWorkspace() {
+        return [];
+      },
+      async expirePendingByWorkspaceIdAndEmail() {},
+      async insert(payload) {
+        return {
+          id: "91",
+          expiresAt: payload.expiresAt
+        };
+      },
+      async findPendingByIdForWorkspace() {
+        return null;
+      },
+      async revokeById() {}
+    }
+  }));
+
+  const result = await service.createInvite(
+    {
+      id: "7",
+      slug: "acme",
+      name: "Acme",
+      ownerUserId: "9",
+      avatarUrl: ""
+    },
+    { id: "9", email: "owner@example.com" },
+    {
+      email: "invitee@example.com",
+      roleSid: "member"
+    }
+  );
+
+  assert.equal(result.inviteDelivery.providerMessageId, "msg-custom");
+  assert.equal(templateCalls.length, 1);
+  assert.equal(templateCalls[0].workspace.name, "Acme");
+  assert.equal(mailerCalls.length, 1);
+  assert.equal(mailerCalls[0].message.subject, "Custom invite");
+  assert.match(mailerCalls[0].inviteUrl, /^https:\/\/app\.example\.test\/invite\//);
+});

package/test/resourcesCanonical.test.js

@@ -5,6 +5,7 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
+import { workspacePendingInvitationsResource } from "../src/shared/resources/workspacePendingInvitationsResource.js";
 import { workspaceInvitesResource } from "../src/shared/resources/workspaceInvitesResource.js";
 import { workspaceMembershipsResource } from "../src/shared/resources/workspaceMembershipsResource.js";
 import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
@@ -78,7 +79,9 @@ test("workspaces-core specialized resource operations expose messages and valida
     { label: "workspaceMembers.invitesList", operation: workspaceMembersResource.operations.invitesList },
     { label: "workspaceMembers.createInvite", operation: workspaceMembersResource.operations.createInvite },
     { label: "workspaceMembers.revokeInvite", operation: workspaceMembersResource.operations.revokeInvite },
-    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite }
+    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite },
+    { label: "workspacePendingInvitations.resolve", operation: workspacePendingInvitationsResource.operations.resolve },
+    { label: "workspacePendingInvitations.list", operation: workspacePendingInvitationsResource.operations.list }
   ];
 
   for (const { label, operation } of operationSpecs) {

package/test/usersRouteResources.test.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
 import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
+import { workspacePendingInvitationsResource } from "../src/shared/resources/workspacePendingInvitationsResource.js";
 import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
 import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
 
@@ -67,7 +68,9 @@ test("workspace settings and invite operations expose canonical validators", ()
     { label: "workspaceMembers.invitesList", operation: workspaceMembersResource.operations.invitesList },
     { label: "workspaceMembers.createInvite", operation: workspaceMembersResource.operations.createInvite },
     { label: "workspaceMembers.revokeInvite", operation: workspaceMembersResource.operations.revokeInvite },
-    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite }
+    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite },
+    { label: "workspacePendingInvitations.resolve", operation: workspacePendingInvitationsResource.operations.resolve },
+    { label: "workspacePendingInvitations.list", operation: workspacePendingInvitationsResource.operations.list }
   ];
 
   for (const { label, operation } of operationSpecs) {

package/test/workspaceInvitesRepository.test.js

@@ -173,6 +173,41 @@ test("workspaceInvitesRepository.findPendingByTokenHash reads from the canonical
   assert.equal(invite?.workspaceSlug, undefined);
 });
 
+test("workspaceInvitesRepository.findByTokenHashWithWorkspace preserves workspace summary fields for public invite resolution", async () => {
+  const { api } = createWorkspaceInvitesApiStub({
+    rows: [
+      {
+        id: "45",
+        workspace: {
+          id: "9",
+          slug: "tonymobily3",
+          name: "TonyMobily3",
+          avatarUrl: "https://example.com/avatar.png"
+        },
+        email: "invitee@example.com",
+        roleSid: "member",
+        status: "accepted",
+        tokenHash: "hash-token",
+        invitedByUser: { id: "1" },
+        expiresAt: "2030-01-01 00:00:00.000",
+        acceptedAt: "2026-03-10 00:00:00.000",
+        revokedAt: null,
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-10 00:00:00.000"
+      }
+    ]
+  });
+  const repository = createRepository({ api, knex: createKnexStub() });
+
+  const invite = await repository.findByTokenHashWithWorkspace("hash-token");
+
+  assert.equal(invite?.id, "45");
+  assert.equal(invite?.status, "accepted");
+  assert.equal(invite?.workspaceSlug, "tonymobily3");
+  assert.equal(invite?.workspaceName, "TonyMobily3");
+  assert.equal(invite?.workspaceAvatarUrl, "https://example.com/avatar.png");
+});
+
 test("workspaceInvitesRepository.markAcceptedById uses the internal invite resource for normalized patch writes", async () => {
   const { api, state } = createWorkspaceInvitesApiStub({
     rowById: new Map([

package/test/workspaceMembersResource.test.js

@@ -29,6 +29,14 @@ test("workspace members invite mutation outputs expose their tracking ids explic
 
   assert.equal(createOutputSchema.properties.createdInviteId.type, "string");
   assert.equal(createOutputSchema.properties.inviteTokenPreview.type, "string");
+  assert.equal(createOutputSchema.properties.inviteUrl.type, "string");
+  const inviteDeliverySchemaName = createOutputSchema.properties.inviteDelivery.allOf[0].$ref.replace(/^#\/definitions\//, "");
+  const inviteDeliverySchema = createOutputSchema.definitions[inviteDeliverySchemaName];
+  assert.deepEqual(inviteDeliverySchema.required, ["status", "message", "providerMessageId"]);
+  assert.deepEqual(
+    inviteDeliverySchema.properties.status.enum,
+    ["sent", "failed", "mailer_unconfigured"]
+  );
   assert.equal(revokeOutputSchema.properties.revokedInviteId.type, "string");
   assert.equal(revokeOutputSchema.properties.roleCatalog["x-json-rest-schema"]?.castType, "object");
   assert.equal(Array.isArray(revokeOutputSchema.properties.roleCatalog.allOf), true);

package/test/workspaceMembersService.test.js

@@ -147,6 +147,101 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
   assert.ok(expiresAt >= before + 30 * 60 * 1000);
   assert.ok(expiresAt <= after + 30 * 60 * 1000);
   assert.equal(response.createdInviteId, "31");
+  assert.equal(response.inviteUrl, `/invite/${encodeURIComponent(response.inviteTokenPreview)}`);
+  assert.deepEqual(response.inviteDelivery, {
+    status: "mailer_unconfigured",
+    message: "No workspace invite mailer is configured.",
+    providerMessageId: ""
+  });
+});
+
+test("workspaceMembersService.createInvite sends generated invite URLs through the configured mailer", async () => {
+  const templateCalls = [];
+  const mailerCalls = [];
+  const service = createService({
+    workspaceMembershipsRepository: {
+      async listActiveByWorkspaceId() {
+        return [];
+      }
+    },
+    workspaceInvitesRepository: {
+      async expirePendingByWorkspaceIdAndEmail(workspaceId, email) {
+        assert.equal(workspaceId, "7");
+        assert.equal(email, "invitee@example.com");
+      },
+      async insert(payload) {
+        assert.equal(payload.workspaceId, "7");
+        assert.equal(payload.email, "invitee@example.com");
+        assert.equal(payload.roleSid, "admin");
+        return {
+          id: "88",
+          expiresAt: payload.expiresAt
+        };
+      },
+      async listPendingByWorkspaceIdWithWorkspace() {
+        return [];
+      },
+      async findPendingByIdForWorkspace() {
+        return null;
+      },
+      async revokeById() {}
+    },
+    inviteExpiresInMs: 30 * 60 * 1000,
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder({ token, workspace }) {
+      return `https://app.example.test/invite/${encodeURIComponent(token)}?workspace=${workspace.slug}`;
+    },
+    workspaceInviteEmailTemplate(payload) {
+      templateCalls.push(payload);
+      return {
+        subject: `Join ${payload.workspace.name}`,
+        text: payload.inviteUrl,
+        html: null
+      };
+    },
+    workspaceInviteMailer: {
+      async sendWorkspaceInvite(payload, options) {
+        mailerCalls.push({ payload, options });
+        return {
+          status: "sent",
+          message: "queued",
+          providerMessageId: "msg-1"
+        };
+      }
+    }
+  });
+
+  const response = await service.createInvite(
+    {
+      id: "7",
+      slug: "acme",
+      name: "Acme",
+      ownerUserId: "9",
+      avatarUrl: ""
+    },
+    { id: "11", email: "owner@example.com" },
+    {
+      email: "Invitee@Example.com",
+      roleSid: "admin"
+    },
+    authorizedOptions(["workspace.members.invite"])
+  );
+
+  assert.equal(response.createdInviteId, "88");
+  assert.match(response.inviteUrl, /^https:\/\/app\.example\.test\/invite\//);
+  assert.deepEqual(response.inviteDelivery, {
+    status: "sent",
+    message: "queued",
+    providerMessageId: "msg-1"
+  });
+  assert.equal(templateCalls.length, 1);
+  assert.equal(templateCalls[0].email, "invitee@example.com");
+  assert.equal(templateCalls[0].workspace.name, "Acme");
+  assert.equal(templateCalls[0].inviteUrl, response.inviteUrl);
+  assert.equal(mailerCalls.length, 1);
+  assert.equal(mailerCalls[0].payload.email, "invitee@example.com");
+  assert.equal(mailerCalls[0].payload.inviteUrl, response.inviteUrl);
+  assert.equal(mailerCalls[0].payload.message.subject, "Join Acme");
 });
 
 test("workspaceMembersService.revokeInvite returns the revoked invite id", async () => {
@@ -237,6 +332,34 @@ test("workspaceMembersService rejects invite operations when invitations are dis
       ),
     /Workspace invitations are disabled/
   );
+  await assert.rejects(
+    () =>
+      service.createInvite(
+        {
+          id: "7",
+          ownerUserId: "9"
+        },
+        { id: "11" },
+        {
+          email: "alice@example.com",
+          roleSid: "member"
+        },
+        authorizedOptions(["workspace.members.invite"])
+      ),
+    /Workspace invitations are disabled/
+  );
+  await assert.rejects(
+    () =>
+      service.revokeInvite(
+        {
+          id: "7",
+          ownerUserId: "9"
+        },
+        "47",
+        authorizedOptions(["workspace.invites.revoke"])
+      ),
+    /Workspace invitations are disabled/
+  );
 });
 
 test("workspaceMembersService.listMembers uses the resolved workspace directly", async () => {

package/test/workspacePendingInvitationsResource.test.js

@@ -31,3 +31,21 @@ test("workspacePendingInvitationsResource output schema accepts already-shaped i
   assert.equal(Array.isArray(outputSchema.properties.pendingInvites.items.allOf), true);
   assert.equal(result.pendingInvites[0].roleSid, "member");
 });
+
+test("workspacePendingInvitationsResource exposes public resolve query and terminal statuses", () => {
+  const querySchema = resolveStructuredSchemaTransportSchema(workspacePendingInvitationsResource.operations.resolve.query, {
+    context: "workspacePendingInvitations.resolve.query",
+    defaultMode: "replace"
+  });
+  const outputSchema = resolveStructuredSchemaTransportSchema(workspacePendingInvitationsResource.operations.resolve.output, {
+    context: "workspacePendingInvitations.resolve.output",
+    defaultMode: "replace"
+  });
+
+  assert.equal(querySchema.properties.token.type, "string");
+  assert.deepEqual(
+    outputSchema.properties.status.enum,
+    ["pending", "expired", "accepted", "revoked", "not_found"]
+  );
+  assert.equal(outputSchema.properties.workspace["x-json-rest-schema"]?.castType, "object");
+});