@jskit-ai/auth-provider-local-core 0.1.4 → 0.1.6

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   "packageVersion": 1,
   "packageId": "@jskit-ai/auth-provider-local-core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "kind": "runtime",
   "description": "Local auth provider with a file backend default and no database requirement.",
   "dependsOn": [
@@ -57,8 +57,8 @@ export default Object.freeze({
   "mutations": {
     "dependencies": {
       "runtime": {
-        "@jskit-ai/auth-core": "0.1.103",
-        "@jskit-ai/kernel": "0.1.105",
+        "@jskit-ai/auth-core": "0.1.105",
+        "@jskit-ai/kernel": "0.1.107",
         "nodemailer": "^7.0.10",
         "dotenv": "^16.4.5"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/auth-provider-local-core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,8 +11,8 @@
     "./server/lib/index": "./src/server/lib/index.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.103",
-    "@jskit-ai/kernel": "0.1.105",
+    "@jskit-ai/auth-core": "0.1.105",
+    "@jskit-ai/kernel": "0.1.107",
     "nodemailer": "^7.0.10"
   }
 }

package/src/server/lib/service.js

@@ -92,10 +92,10 @@ function buildActor(user, profile = null) {
   });
 }
 
-async function buildAuthPayload({ user, session, profileProjector }) {
+async function buildAuthPayload({ user, session, profileProjector, profileOptions = {} }) {
   let profile = buildProfile(user);
   if (profileProjector && typeof profileProjector.syncIdentityProfile === "function") {
-    profile = await profileProjector.syncIdentityProfile(profile);
+    profile = await profileProjector.syncIdentityProfile(profile, profileOptions);
     if (!profile || typeof profile !== "object") {
       throw new Error("auth.profile.projector.syncIdentityProfile() must return a profile object.");
     }
@@ -166,6 +166,20 @@ function validateEmailInput(email) {
   return normalized;
 }
 
+function normalizeInvitationInput(value = null) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const token = String(value.token || value.inviteToken || "").trim();
+  if (!token) {
+    return null;
+  }
+  return {
+    token,
+    source: String(value.source || "workspace-invite").trim() || "workspace-invite"
+  };
+}
+
 async function maybeSendRecoveryEmail(config, recoveryUrl, email) {
   if (!config.smtpConfigured) {
     return;
@@ -191,7 +205,13 @@ async function maybeSendRecoveryEmail(config, recoveryUrl, email) {
   });
 }
 
-function createLocalAuthService({ backend, config, profileProjector = null, passwordStrategy = null }) {
+function createLocalAuthService({
+  backend,
+  config,
+  profileProjector = null,
+  passwordStrategy = null,
+  invitationContextResolver = null
+}) {
   if (!backend || typeof backend.withTransaction !== "function") {
     throw new Error("Local auth requires auth.local.backend with withTransaction().");
   }
@@ -281,10 +301,31 @@ function createLocalAuthService({ backend, config, profileProjector = null, pass
     });
   }
 
+  async function resolveProfileOptionsForRegistration(input = {}, { email } = {}) {
+    const invitation = normalizeInvitationInput(input.invitation);
+    if (!invitation) {
+      return {};
+    }
+
+    let resolvedInvitation = invitation;
+    if (invitationContextResolver && typeof invitationContextResolver.resolveInvitationContext === "function") {
+      resolvedInvitation = await invitationContextResolver.resolveInvitationContext({
+        ...invitation,
+        email
+      });
+    }
+
+    return {
+      source: resolvedInvitation?.source || "workspace-invite",
+      invitation: resolvedInvitation
+    };
+  }
+
   async function register(input = {}) {
     const email = validateEmailInput(input.email);
     validatePasswordInput(input.password);
     const displayName = normalizeDisplayName(input.displayName, email);
+    const profileOptions = await resolveProfileOptionsForRegistration(input, { email });
     const password = await passwords.hashPassword(input.password);
     const result = await backend.withTransaction(async (tx) => {
       const existing = await tx.users.findByEmail(email);
@@ -303,7 +344,12 @@ function createLocalAuthService({ backend, config, profileProjector = null, pass
       };
     });
     return {
-      ...(await buildAuthPayload({ user: result.user, session: result.session, profileProjector })),
+      ...(await buildAuthPayload({
+        user: result.user,
+        session: result.session,
+        profileProjector,
+        profileOptions
+      })),
       requiresEmailConfirmation: false
     };
   }

package/src/server/providers/AuthLocalServiceProvider.js

@@ -174,12 +174,26 @@ class AuthLocalServiceProvider {
       const backend = scope.make("auth.local.backend");
       const profileProjector = scope.has("auth.profile.projector")
         ? {
-            async syncIdentityProfile(profile) {
+            async syncIdentityProfile(profile, options = {}) {
               const projector = scope.make("auth.profile.projector");
               if (!projector || typeof projector.syncIdentityProfile !== "function") {
                 throw new Error("auth.profile.projector.syncIdentityProfile() must be a function.");
               }
-              return projector.syncIdentityProfile(profile);
+              return projector.syncIdentityProfile(profile, options);
+            }
+          }
+        : null;
+      const invitationContextResolver = scope.has("auth.invitationContextResolver")
+        ? {
+            async resolveInvitationContext(invitation, options = {}) {
+              const resolver = scope.make("auth.invitationContextResolver");
+              if (typeof resolver === "function") {
+                return resolver(invitation, options);
+              }
+              if (!resolver || typeof resolver.resolveInvitationContext !== "function") {
+                throw new Error("auth.invitationContextResolver.resolveInvitationContext() must be a function.");
+              }
+              return resolver.resolveInvitationContext(invitation, options);
             }
           }
         : null;
@@ -190,7 +204,8 @@ class AuthLocalServiceProvider {
         backend,
         config,
         profileProjector,
-        passwordStrategy
+        passwordStrategy,
+        invitationContextResolver
       });
     });
   }

package/test/providerRuntime.test.js

@@ -50,7 +50,12 @@ function createReplyFixture() {
   };
 }
 
-async function createStartedApp({ profileProjector = null, profileProjectorFactory = null, passwordStrategy = null } = {}) {
+async function createStartedApp({
+  profileProjector = null,
+  profileProjectorFactory = null,
+  passwordStrategy = null,
+  invitationContextResolver = null
+} = {}) {
   const storeDir = await fs.mkdtemp(path.join(os.tmpdir(), "jskit-auth-local-"));
   const app = createApplication();
   app.instance("appConfig", createAppConfigFixture());
@@ -79,6 +84,9 @@ async function createStartedApp({ profileProjector = null, profileProjectorFacto
   if (passwordStrategy) {
     app.instance("auth.local.passwordStrategy", passwordStrategy);
   }
+  if (invitationContextResolver) {
+    app.instance("auth.invitationContextResolver", invitationContextResolver);
+  }
   await app.start({
     providers: [
       ActionRuntimeServiceProvider,
@@ -586,6 +594,71 @@ test("local auth provider projects app profile when auth.profile.projector is in
   assert.equal(registered.actor.profileSource, "users");
 });
 
+test("local auth provider passes resolved invitation context into profile projection during registration", async () => {
+  const resolverCalls = [];
+  const projectionCalls = [];
+  const { app } = await createStartedApp({
+    invitationContextResolver: {
+      async resolveInvitationContext(invitation) {
+        resolverCalls.push(invitation);
+        return {
+          token: invitation.token,
+          workspaceId: "workspace-7",
+          workspaceSlug: "acme",
+          workspaceName: "Acme",
+          email: invitation.email,
+          roleSid: "member",
+          expiresAt: "2030-01-01T00:00:00.000Z"
+        };
+      }
+    },
+    profileProjector: {
+      async syncIdentityProfile(profile, options) {
+        projectionCalls.push({ profile, options });
+        return {
+          ...profile,
+          id: "invited-app-user",
+          profileSource: "users"
+        };
+      }
+    }
+  });
+  const authService = app.make("authService");
+
+  const registered = await authService.register({
+    email: "Invitee@Example.com",
+    password: "invited password",
+    displayName: "Invited",
+    invitation: {
+      token: "invite-token",
+      source: "workspace-invite"
+    }
+  });
+
+  assert.deepEqual(resolverCalls, [
+    {
+      token: "invite-token",
+      source: "workspace-invite",
+      email: "invitee@example.com"
+    }
+  ]);
+  assert.equal(projectionCalls.length, 1);
+  assert.equal(projectionCalls[0].profile.email, "invitee@example.com");
+  assert.deepEqual(projectionCalls[0].options, {
+    source: "workspace-invite",
+    invitation: {
+      token: "invite-token",
+      workspaceId: "workspace-7",
+      workspaceSlug: "acme",
+      workspaceName: "Acme",
+      email: "invitee@example.com",
+      roleSid: "member",
+      expiresAt: "2030-01-01T00:00:00.000Z"
+    }
+  });
+  assert.equal(registered.actor.appUserId, "invited-app-user");
+});
+
 test("local auth provider rejects AUTH_PROVIDER mismatches", async () => {
   const app = createApplication();
   app.instance("appConfig", createAppConfigFixture());