: null}
>
{signup ? 'Create an account' : 'Sign in'}
@@ -27,6 +45,7 @@ export function SignIn({ mode = 'login', next, sent = false, error, user = null
<>
+
Saved searches
{saved.length ? (
diff --git a/bun.lock b/bun.lock
index 2a2e035..01bff64 100644
--- a/bun.lock
+++ b/bun.lock
@@ -41,6 +41,7 @@
"dependencies": {
"@profullstack/emailer": "^1.0.3",
"@profullstack/footer": "latest",
+ "@profullstack/profile": "0.1.2",
"@profullstack/r4ck": "workspace:*",
"@profullstack/throttle": "^0.3.3",
"@profullstack/x402-gateway": "^0.11.0",
@@ -191,6 +192,8 @@
"@profullstack/keys": ["@profullstack/keys@0.1.0", "", {}, "sha512-Vys47LvS5ivhdZu4SYOxh9Le3DEmWhjP0+CtrU45RhXAbY0ZFG/2Dk9V1bIIUGDp8UWMJqctvUD21JrNjfh04w=="],
+ "@profullstack/profile": ["@profullstack/profile@0.1.2", "", { "peerDependencies": { "@libsql/client": ">=0.6.0", "postgres": "^3.4.0", "react": ">=18" }, "optionalPeers": ["@libsql/client", "postgres", "react"], "bin": { "profile": "src/cli.js" } }, "sha512-IRpMa8xFWIs5UnZiOZt5GSQCsNM7utq1ZgSqqJ/Buye89GcKCxhMtfRIe1zRHe+96Lc2egEuKeCfmNtxa3ej5Q=="],
+
"@profullstack/r4ck": ["@profullstack/r4ck@workspace:apps/cli"],
"@profullstack/scraper-daemon": ["@profullstack/scraper-daemon@0.2.1", "", { "peerDependencies": { "bullmq": ">=6", "ioredis": ">=5" }, "optionalPeers": ["bullmq", "ioredis"], "bin": { "scraper-daemon": "bin/scraper-daemon.js" } }, "sha512-oqmN0eOPmNAz7Q88XOIL2xEb87jc32IbIWyteUtmIhqqLHHQhu19lsgrrtoNClH/6tQoI7cSQFCAnoFH1YoNXw=="],
diff --git a/packages/auth/src/index.js b/packages/auth/src/index.js
index f900e8a..81ec2d5 100644
--- a/packages/auth/src/index.js
+++ b/packages/auth/src/index.js
@@ -31,12 +31,14 @@ export const expectedOrigins = (() => {
const hashToken = (t) => createHash('sha256').update(t).digest();
-export async function createLoginLink(email, { next } = {}) {
+export async function createLoginLink(email, { next, profile = null } = {}) {
const token = randomBytes(32).toString('base64url');
await q.insertLoginToken({
tokenHash: hashToken(token),
email: email.trim().toLowerCase(),
expiresAt: new Date(Date.now() + TOKEN_TTL_MINUTES * 60_000),
+ // Signup form fields, already validated by the caller; saved on verify.
+ profile,
});
const url = new URL('/auth/magic', config.siteUrl);
url.searchParams.set('t', token);
@@ -46,8 +48,10 @@ export async function createLoginLink(email, { next } = {}) {
/** Also the registration path: an unknown address gets an account here. */
export async function consumeLoginLink(token, { userAgent } = {}) {
- const email = await q.consumeLoginToken(hashToken(token));
+ const tokenHash = hashToken(token);
+ const email = await q.consumeLoginToken(tokenHash);
if (!email) return null;
+ const profile = await q.takeSignupProfile(tokenHash);
const user = await q.findOrCreateUser(email, {
admin: config.adminEmails.includes(String(email).toLowerCase()),
});
@@ -56,7 +60,7 @@ export async function consumeLoginLink(token, { userAgent } = {}) {
ttlDays: config.session.ttlDays,
userAgent,
});
- return { user, sessionId };
+ return { user, sessionId, profile };
}
export async function passkeyRegistrationOptions(user) {
diff --git a/packages/db/migrations/0002_user_profiles.sql b/packages/db/migrations/0002_user_profiles.sql
new file mode 100644
index 0000000..4ce74ae
--- /dev/null
+++ b/packages/db/migrations/0002_user_profiles.sql
@@ -0,0 +1,39 @@
+-- The shared Profullstack profile: email, first_name, last_name, company_domain,
+-- job_title, linkedin_url, owned by @profullstack/profile.
+--
+-- The package's own table, keyed by users.id. DDL is its
+-- `profile schema --key user_id --key-type uuid` output. No foreign key, as the
+-- package documents; deleting a user is the host's job (/api/account/delete).
+create table if not exists "user_profiles" (
+ "user_id" uuid primary key,
+ "email" text,
+ "first_name" text,
+ "last_name" text,
+ "company_domain" text,
+ "job_title" text,
+ "linkedin_url" text,
+ "created_at" timestamptz not null default now(),
+ "updated_at" timestamptz not null default now()
+);
+create index if not exists "user_profiles_email" on "user_profiles" (lower("email"));
+create index if not exists "user_profiles_company_domain" on "user_profiles" ("company_domain");
+
+-- The account row is only created when the emailed link is spent, so the fields a
+-- signup typed ride on the token until then. Validated before they are stored
+-- here, and saved only once the link proves the mailbox.
+alter table login_tokens add column if not exists profile jsonb;
+
+-- One-time backfill from users.display_name. First word to first_name, the rest
+-- to last_name. Only blanks are filled, so a re-run never overwrites anything.
+insert into user_profiles (user_id, email, first_name, last_name)
+select
+ u.id,
+ lower(u.email::text),
+ split_part(btrim(u.display_name), ' ', 1),
+ nullif(btrim(substr(btrim(u.display_name), length(split_part(btrim(u.display_name), ' ', 1)) + 1)), '')
+from users u
+where nullif(btrim(u.display_name), '') is not null
+on conflict (user_id) do update set
+ email = coalesce(user_profiles.email, excluded.email),
+ first_name = coalesce(user_profiles.first_name, excluded.first_name),
+ last_name = coalesce(user_profiles.last_name, excluded.last_name);
diff --git a/packages/db/src/accounts.js b/packages/db/src/accounts.js
index ae6dba3..bf643e4 100644
--- a/packages/db/src/accounts.js
+++ b/packages/db/src/accounts.js
@@ -1,4 +1,4 @@
-import { pgArray, sql, withJson } from './index.js';
+import { jsonb, pgArray, sql, withJson } from './index.js';
/* ------------------------------------------------------------- accounts -- */
@@ -26,8 +26,37 @@ export async function countUsers() {
return n;
}
-export async function insertLoginToken({ tokenHash, email, expiresAt }) {
- await sql`insert into login_tokens ${sql({ token_hash: tokenHash, email, expires_at: expiresAt })}`;
+/**
+ * `profile` is the validated signup form (@profullstack/profile fields), held on
+ * the token because the account row does not exist until the link is spent.
+ * Bound as text and cast via ::text: Bun SQL binds a bare `::jsonb` string as a JSON string scalar.
+ */
+export async function insertLoginToken({ tokenHash, email, expiresAt, profile = null }) {
+ await sql`
+ insert into login_tokens (token_hash, email, expires_at, profile)
+ values (${tokenHash}, ${email}, ${expiresAt}, ${profile ? JSON.stringify(profile) : null}::text::jsonb)
+ `;
+}
+
+/**
+ * The signup fields a just-spent link carried, handed out once and then cleared.
+ * Only a consumed token answers, so this can never run ahead of the sign-in.
+ */
+export async function takeSignupProfile(tokenHash) {
+ // RETURNING sees the row after the update, so the old value comes from a
+ // subquery: `returning profile` here would always hand back the null.
+ const [row] = await sql`
+ update login_tokens t set profile = null
+ from (
+ select token_hash, profile from login_tokens
+ where token_hash = ${tokenHash} and consumed_at is not null and profile is not null
+ for update
+ ) old
+ where t.token_hash = old.token_hash
+ returning old.profile
+ `;
+ if (!row) return null;
+ return jsonb(row.profile, null);
}
/** Single-use by construction: the update is the consumption. Returns the address. */
diff --git a/test/api.test.js b/test/api.test.js
index 4379661..a30e805 100644
--- a/test/api.test.js
+++ b/test/api.test.js
@@ -375,6 +375,105 @@ if (!url) {
).status,
).toBe(400);
});
+ test('signup asks for the profile fields; sign-in does not', async () => {
+ const signup = await (
+ await app.request('/signup', { headers: { accept: 'text/html' } })
+ ).text();
+ for (const name of ['first_name', 'last_name', 'company_domain', 'job_title', 'linkedin_url'])
+ expect(signup).toContain(`name="${name}"`);
+ expect(signup.match(/name="email"/g)?.length).toBe(1);
+ expect(signup).toContain('/vendor-profile.js');
+ const login = await (
+ await app.request('/login', { headers: { accept: 'text/html' } })
+ ).text();
+ expect(login).not.toContain('name="first_name"');
+ const script = await app.request('/vendor-profile.js');
+ expect(script.headers.get('content-type')).toContain('javascript');
+ });
+ test('a signup with the fields stores them on verify', async () => {
+ const post = (fields) =>
+ app.request('/api/auth/magic', {
+ method: 'POST',
+ headers: { accept: 'text/html', 'content-type': 'application/x-www-form-urlencoded' },
+ body: new URLSearchParams({ mode: 'signup', next: '/settings', ...fields }),
+ });
+ await sql`delete from login_tokens where email = 'ada@acme.test'`;
+ await sql`delete from users where email = 'ada@acme.test'`;
+ // Refused before any link exists, with what was typed kept.
+ const refused = await post({ email: 'ada@acme.test', first_name: 'Ada' });
+ expect(refused.status).toBe(400);
+ const page = await refused.text();
+ expect(page).toContain('value="Ada"');
+ expect(page).toContain('name="last_name"');
+ expect((await sql`select 1 from login_tokens where email = 'ada@acme.test'`).length).toBe(0);
+
+ const ok = await post({
+ email: 'Ada@Acme.test',
+ first_name: 'Ada',
+ last_name: 'Lovelace',
+ company_domain: 'https://www.acme.test/about',
+ job_title: 'VP Engineering',
+ linkedin_url: 'in/ada-lovelace',
+ });
+ expect(ok.status).toBe(200);
+ // Carried on the token, normalized, as a jsonb object (not a JSON string).
+ const [row] = await sql`
+ select profile, jsonb_typeof(profile) as t from login_tokens
+ where email = 'ada@acme.test' and profile is not null limit 1
+ `;
+ expect(row.t).toBe('object');
+ // The emailed URL is not readable here, so a link is minted with the same
+ // carried fields; spending it must save them.
+ const carried = typeof row.profile === 'string' ? JSON.parse(row.profile) : row.profile;
+ const link = await auth.createLoginLink('ada@acme.test', { profile: carried });
+ const r = await app.request(link.replace(/^https?:\/\/[^/]+/, ''), {
+ headers: { accept: 'text/html' },
+ });
+ expect(r.status).toBe(303);
+ const cookie = r.headers.get('set-cookie').split(';')[0];
+ const got = await app.request('/api/v1/me/profile', {
+ headers: { accept: 'application/json', cookie },
+ });
+ expect(got.status).toBe(200);
+ expect(JSON.stringify(await got.json())).toContain('"company_domain":"acme.test"');
+ const [saved] = await sql`
+ select p.* from user_profiles p join users u on u.id = p.user_id
+ where u.email = 'ada@acme.test'
+ `;
+ expect(saved).toMatchObject({
+ email: 'ada@acme.test',
+ first_name: 'Ada',
+ last_name: 'Lovelace',
+ company_domain: 'acme.test',
+ job_title: 'VP Engineering',
+ linkedin_url: 'https://www.linkedin.com/in/ada-lovelace',
+ });
+ // Settings shows the same fields, prefilled, and saves them without script.
+ const settings = await app.request('/settings', { headers: { accept: 'text/html', cookie } });
+ expect(await settings.text()).toContain('value="VP Engineering"');
+ const edit = await app.request('/settings/contact', {
+ method: 'POST',
+ headers: {
+ accept: 'text/html',
+ cookie,
+ 'content-type': 'application/x-www-form-urlencoded',
+ },
+ body: new URLSearchParams({ first_name: 'Ada', last_name: 'King', job_title: 'CTO' }),
+ });
+ expect(edit.status).toBe(303);
+ const [edited] = await sql`
+ select p.last_name, p.job_title from user_profiles p join users u on u.id = p.user_id
+ where u.email = 'ada@acme.test'
+ `;
+ expect(edited).toEqual({ last_name: 'King', job_title: 'CTO' });
+ // Handed out once: the spent token no longer holds it.
+ const spent = await sql`
+ select 1 from login_tokens
+ where email = 'ada@acme.test' and consumed_at is not null and profile is not null
+ `;
+ expect(spent.length).toBe(0);
+ expect((await app.request('/api/v1/me/profile')).status).toBe(401);
+ });
});
describe('mcp', () => {