@openlup/platform 0.15.0 → 0.16.0

package/dist/identity/customerVerifyOtpHandler.js

@@ -0,0 +1,41 @@
+import { createIdentityResponder } from "./response.js";
+import { z } from "zod";
+z.config({ jitless: true });
+const customerOtpVerifyRequestSchema = z.object({
+    email: z.string().trim().toLowerCase().email().max(160),
+    token: z.string().trim().min(16).max(256),
+}).strict();
+const customerOtpVerifyResponseSchema = z.object({
+    accessToken: z.string().min(1),
+    expiresAt: z.string().datetime({ offset: true }),
+    user: z.object({ id: z.guid(), email: z.string().email() }).strict(),
+}).strict();
+export function createCustomerVerifyOtpHandler(options) {
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = createIdentityResponder(options);
+    return async (req, res) => {
+        if (!options.enabled()) {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Customer accounts are disabled");
+            return;
+        }
+        if (req.method !== "POST")
+            return sendMethodNotAllowed(res, ["POST"]);
+        const request = customerOtpVerifyRequestSchema.safeParse(req.body);
+        if (!request.success) {
+            sendBffError(res, "BAD_REQUEST", "Invalid one-time code request", { details: request.error.flatten() });
+            return;
+        }
+        const resolved = options.resolveSession(options.env);
+        if (!resolved.binding) {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Customer auth is not configured", {
+                details: { feature: "customer_auth", reason: resolved.error },
+            });
+            return;
+        }
+        const session = await resolved.binding.verifyChallenge(request.data.token);
+        if (!session) {
+            sendBffError(res, "UNAUTHORIZED", "One-time code is invalid or expired");
+            return;
+        }
+        sendBffSuccess(res, customerOtpVerifyResponseSchema.parse(session));
+    };
+}

package/dist/identity/directOperatorInvitationStore.d.ts

@@ -0,0 +1,19 @@
+import { type PgQueryExecutor, type PostgresDataGatewayEnv, type PostgresDataGatewayOptions } from "../data/index.js";
+import type { OperatorInvitationStore } from "./operatorInvitationPorts.js";
+/** Owner-authority lane, never the actor gateway. One transaction per command. */
+export declare function createDirectOperatorInvitationStore(env: PostgresDataGatewayEnv, options?: PostgresDataGatewayOptions): OperatorInvitationStore & {
+    close(): Promise<void>;
+};
+/** Principal creation commits independently; an invitation failure leaves it reusable. */
+export declare function createDirectOperatorIdentityDirectory(env: PostgresDataGatewayEnv, options?: PostgresDataGatewayOptions): {
+    ensurePrincipal(input: {
+        email: string;
+        redirectTo: string;
+    }): Promise<{
+        principalId: string;
+        created: boolean;
+    }>;
+    close: () => Promise<void>;
+};
+/** Trusted authentication only; caller owns the transaction, including challenge consumption. */
+export declare function acceptDirectOperatorInvitationInTransaction(db: PgQueryExecutor, id: string): Promise<import("./contracts/operatorInvitations.js").OperatorInvitationAcceptance>;

package/dist/identity/directOperatorInvitationStore.js

@@ -0,0 +1,193 @@
+import { createPostgresRoleFreeTransactionLane } from "../data/index.js";
+import { assertOperatorInvitationTtl, invitationFailure } from "./operatorInvitationLifecycle.js";
+const iso = (value) => value instanceof Date ? value.toISOString() : new Date(String(value)).toISOString();
+const role = (value) => value === "distributor" ? "distributor" : "admin";
+const snapshot = (row) => ({ principalId: String(row.principal_id), role: role(row.role) });
+function result(row, code) {
+    return { ...snapshot(row), code, membershipState: "invited", invitationId: String(row.invitation_id), invitedAt: iso(row.invited_at), expiresAt: iso(row.expires_at) };
+}
+async function event(db, action, before, after, actor) {
+    await db.query(`INSERT INTO public.identity_operator_invitation_events
+    (event_id, invitation_id, principal_id, action, actor_kind, actor_principal_id, old_value, new_value, occurred_at)
+    VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, $6::jsonb, $7::jsonb, clock_timestamp())`, [after.invitation_id, after.principal_id, action, actor ? "human" : "system", actor, JSON.stringify(before ?? {}), JSON.stringify(after)]);
+}
+async function lock(db, id) {
+    const principal = (await db.query("SELECT principal_id, email FROM public.platform_human_principals WHERE principal_id = $1", [id])).rows[0];
+    if (!principal)
+        return null;
+    await db.query("SELECT pg_advisory_xact_lock(hashtext($1)::bigint)", [`operator_invitation:${String(principal.email).trim().toLowerCase()}`]);
+    return principal;
+}
+async function membership(db, id) {
+    return (await db.query("SELECT * FROM public.platform_human_memberships WHERE principal_id = $1 FOR UPDATE", [id])).rows[0] ?? null;
+}
+async function machine(db, id) {
+    return (await db.query("SELECT EXISTS (SELECT 1 FROM public.platform_control_operators WHERE principal_id = $1) AS present", [id])).rows[0]?.present === true;
+}
+async function lockCommandMemberships(db, actor, target) {
+    // Lock both rows in the same order before taking either actor or target locks.
+    await db.query("SELECT principal_id FROM public.platform_human_memberships WHERE principal_id = ANY($1::uuid[]) ORDER BY principal_id FOR UPDATE", [[actor, target]]);
+}
+async function administrator(db, id) {
+    const row = (await db.query("SELECT role, membership_state FROM public.platform_human_memberships WHERE principal_id = $1 FOR SHARE", [id])).rows[0];
+    if (row?.role !== "admin" || row.membership_state !== "active" || await machine(db, id))
+        throw invitationFailure("HUMAN_ADMIN_REQUIRED", "FORBIDDEN");
+}
+async function invitation(db, id) {
+    const row = (await db.query("SELECT * FROM public.identity_operator_invitations WHERE principal_id = $1 FOR UPDATE", [id])).rows[0];
+    if (!row)
+        return null;
+    // Capture the database clock after serialization; equality is already expired.
+    const expiredNow = (await db.query("SELECT clock_timestamp() >= $1::timestamptz AS expired", [row.expires_at])).rows[0].expired;
+    if (row.phase === "invited" && expiredNow === true) {
+        const expired = (await db.query("UPDATE public.identity_operator_invitations SET phase = 'expired', closed_at = expires_at WHERE principal_id = $1 RETURNING *", [id])).rows[0];
+        await event(db, "expire", row, expired, null);
+        return expired;
+    }
+    return row;
+}
+/** Owner-authority lane, never the actor gateway. One transaction per command. */
+export function createDirectOperatorInvitationStore(env, options = {}) {
+    const lane = createPostgresRoleFreeTransactionLane(env, options);
+    const run = (work) => lane.run((db) => work(db));
+    return {
+        issue(input) {
+            assertOperatorInvitationTtl(input.ttlSeconds);
+            return run(async (db) => {
+                // Serialize same-target commands, then lock both memberships in order.
+                const principal = await lock(db, input.targetPrincipalId);
+                await lockCommandMemberships(db, input.actorPrincipalId, input.targetPrincipalId);
+                await administrator(db, input.actorPrincipalId);
+                if ((await db.query("SELECT 1 FROM public.identity_privacy_erasures WHERE principal_id = $1", [input.targetPrincipalId])).rows.length)
+                    return { code: "IDENTITY_CONFLICT" };
+                const email = input.email.trim().toLowerCase();
+                if (!principal || String(principal.email).trim().toLowerCase() !== email || await machine(db, input.targetPrincipalId))
+                    return { code: "IDENTITY_CONFLICT" };
+                const member = await membership(db, input.targetPrincipalId);
+                if (member?.membership_state === "active")
+                    return { code: "MEMBERSHIP_ALREADY_ACTIVE" };
+                const previous = await invitation(db, input.targetPrincipalId);
+                if (previous?.phase === "invited")
+                    return previous.role === input.role ? result(previous, "ALREADY_INVITED") : { code: "INVITATION_ROLE_CONFLICT" };
+                const collision = (await db.query("SELECT principal_id FROM public.identity_operator_invitations WHERE email_key = $1", [email])).rows[0];
+                if (collision && collision.principal_id !== input.targetPrincipalId)
+                    return { code: "IDENTITY_CONFLICT" };
+                const row = (await db.query(`WITH stamp AS (SELECT clock_timestamp() AS at)
+          INSERT INTO public.identity_operator_invitations
+          (principal_id, invitation_id, email_key, role, phase, invited_by, invited_at, expires_at)
+          SELECT $1, gen_random_uuid(), $2, $3, 'invited', $4, stamp.at, stamp.at + $5 * interval '1 second' FROM stamp WHERE true
+          ON CONFLICT (principal_id) DO UPDATE SET invitation_id = EXCLUDED.invitation_id, email_key = EXCLUDED.email_key,
+          role = EXCLUDED.role, phase = 'invited', invited_by = EXCLUDED.invited_by, invited_at = EXCLUDED.invited_at,
+          expires_at = EXCLUDED.expires_at, accepted_at = NULL, closed_at = NULL RETURNING *`, [input.targetPrincipalId, email, input.role, input.actorPrincipalId, input.ttlSeconds])).rows[0];
+                await event(db, previous || member ? "reissue" : "issue", previous, row, input.actorPrincipalId);
+                return result(row, previous || member ? "INVITATION_REISSUED" : "INVITATION_CREATED");
+            });
+        },
+        read(id) {
+            return run(async (db) => {
+                if (!await lock(db, id))
+                    return null;
+                const member = await membership(db, id);
+                if (member?.membership_state === "active")
+                    return { ...snapshot(member), membershipState: "active" };
+                const pending = await invitation(db, id);
+                if (pending && pending.phase !== "accepted")
+                    return { ...snapshot(pending), membershipState: pending.phase === "invited" ? "invited" : pending.phase === "expired" ? "expired" : "revoked" };
+                return member ? { ...snapshot(member), membershipState: "revoked" } : null;
+            });
+        },
+        acceptOperatorInvitation(id) {
+            return run((db) => acceptDirectOperatorInvitationInTransaction(db, id));
+        },
+        remove(input) {
+            return run(async (db) => {
+                const principal = await lock(db, input.targetPrincipalId);
+                await lockCommandMemberships(db, input.actorPrincipalId, input.targetPrincipalId);
+                await administrator(db, input.actorPrincipalId);
+                if (input.actorPrincipalId === input.targetPrincipalId)
+                    throw invitationFailure("SELF_REVOKE_FORBIDDEN", "FORBIDDEN");
+                if (!principal || await machine(db, input.targetPrincipalId))
+                    throw invitationFailure("IDENTITY_CONFLICT");
+                const member = await membership(db, input.targetPrincipalId);
+                const pending = await invitation(db, input.targetPrincipalId);
+                if (pending?.phase === "invited") {
+                    const cancelled = (await db.query("UPDATE public.identity_operator_invitations SET phase = 'cancelled', closed_at = clock_timestamp() WHERE principal_id = $1 RETURNING *", [input.targetPrincipalId])).rows[0];
+                    await event(db, "cancel", pending, cancelled, input.actorPrincipalId);
+                }
+                if (member?.membership_state === "active")
+                    await db.query("SELECT public.platform_revoke_human_membership($1, $2, $3)", [input.actorPrincipalId, input.targetPrincipalId, input.reason ?? null]);
+                if (!member && !pending)
+                    throw invitationFailure("ADMIN_NOT_FOUND", "BAD_REQUEST");
+                return { revoked: true };
+            });
+        },
+        close: lane.close,
+    };
+}
+/** Principal creation commits independently; an invitation failure leaves it reusable. */
+export function createDirectOperatorIdentityDirectory(env, options = {}) {
+    const lane = createPostgresRoleFreeTransactionLane(env, options);
+    return {
+        ensurePrincipal(input) {
+            const email = input.email.trim().toLowerCase();
+            return lane.run(async (executor) => {
+                const db = executor;
+                await db.query("SELECT pg_advisory_xact_lock(hashtext($1)::bigint)", [`operator_invitation:${email}`]);
+                const matches = (await db.query("SELECT principal_id FROM public.platform_human_principals WHERE lower(btrim(email)) = $1", [email])).rows;
+                if (matches.length > 1)
+                    throw invitationFailure("IDENTITY_CONFLICT");
+                if (matches[0]) {
+                    const principalId = String(matches[0].principal_id);
+                    if (await machine(db, principalId))
+                        throw invitationFailure("IDENTITY_CONFLICT");
+                    return { principalId, created: false };
+                }
+                const row = (await db.query("INSERT INTO public.platform_human_principals (principal_id, email) VALUES (gen_random_uuid(), $1) RETURNING principal_id", [email])).rows[0];
+                return { principalId: String(row.principal_id), created: true };
+            });
+        },
+        close: lane.close,
+    };
+}
+/** Trusted authentication only; caller owns the transaction, including challenge consumption. */
+export async function acceptDirectOperatorInvitationInTransaction(db, id) {
+    if (!await lock(db, id) || await machine(db, id))
+        return { code: "NO_INVITATION" };
+    if ((await db.query("SELECT 1 FROM public.identity_privacy_erasures WHERE principal_id = $1", [id])).rows.length)
+        return { code: "INVITATION_REVOKED" };
+    const member = await membership(db, id);
+    if (member?.membership_state === "active") {
+        if (member.role !== "admin" && member.role !== "distributor")
+            return { code: "NO_INVITATION" };
+        return { code: "ALREADY_ACTIVE", role: member.role };
+    }
+    const pending = await invitation(db, id);
+    if (!pending)
+        return { code: "NO_INVITATION" };
+    if (pending.phase === "expired")
+        return { code: "INVITATION_EXPIRED" };
+    if (pending.phase !== "invited" || (pending.role !== "admin" && pending.role !== "distributor"))
+        return { code: "INVITATION_REVOKED" };
+    const clock = (await db.query("WITH stamp AS (SELECT clock_timestamp() AS at) SELECT at, at >= $1::timestamptz AS expired FROM stamp", [pending.expires_at])).rows[0];
+    const at = clock.at;
+    if (clock.expired === true) {
+        const expired = (await db.query("UPDATE public.identity_operator_invitations SET phase = 'expired', closed_at = expires_at WHERE principal_id = $1 RETURNING *", [id])).rows[0];
+        await event(db, "expire", pending, expired, null);
+        return { code: "INVITATION_EXPIRED" };
+    }
+    if (member) {
+        const setting = (await db.query("SELECT current_setting('app.platform_human_membership_revoke', true) AS previous")).rows[0]?.previous;
+        await db.query("SELECT set_config('app.platform_human_membership_revoke', 'true', true)");
+        await db.query(`UPDATE public.platform_human_memberships SET membership_state = 'active', membership_provenance = 'invitation',
+      membership_accepted_at = $2, membership_revoked_at = NULL, membership_revoked_by = NULL, membership_revocation_reason = NULL WHERE principal_id = $1`, [id, at]);
+        await db.query("UPDATE public.platform_human_memberships SET role = $2 WHERE principal_id = $1", [id, pending.role]);
+        await db.query("SELECT set_config('app.platform_human_membership_revoke', $1, true)", [setting ?? ""]);
+    }
+    else {
+        await db.query(`INSERT INTO public.platform_human_memberships (principal_id, role, membership_state, membership_provenance, membership_accepted_at)
+      VALUES ($1, $2, 'active', 'invitation', $3)`, [id, pending.role, at]);
+    }
+    const accepted = (await db.query("UPDATE public.identity_operator_invitations SET phase = 'accepted', accepted_at = $2, closed_at = $2 WHERE principal_id = $1 RETURNING *", [id, at])).rows[0];
+    await event(db, "accept", pending, accepted, id);
+    return { code: "ACTIVATED", role: role(pending.role) };
+}

package/dist/identity/emailTrustPolicy.d.ts

@@ -0,0 +1,14 @@
+import type { EmailTrustFailureCode } from "./contracts/emailTrust.js";
+export type EmailTrustAssessment = {
+    trusted: true;
+} | {
+    trusted: false;
+    code: EmailTrustFailureCode;
+};
+export interface EmailTrustPolicy {
+    assess(): Promise<EmailTrustAssessment>;
+}
+/** Explicitly retain verifier-only admission. This does not bypass mailbox verification. */
+export declare function createVerifierResultOnlyEmailTrustPolicy(): EmailTrustPolicy;
+/** Invalid, absent or throwing JavaScript bindings fail closed, including invalid results. */
+export declare function assessEmailTrust(policy: EmailTrustPolicy): Promise<EmailTrustAssessment>;

package/dist/identity/emailTrustPolicy.js

@@ -0,0 +1,16 @@
+/** Explicitly retain verifier-only admission. This does not bypass mailbox verification. */
+export function createVerifierResultOnlyEmailTrustPolicy() {
+    return { async assess() { return { trusted: true }; } };
+}
+/** Invalid, absent or throwing JavaScript bindings fail closed, including invalid results. */
+export async function assessEmailTrust(policy) {
+    try {
+        const result = await policy.assess();
+        if (result?.trusted === true)
+            return { trusted: true };
+        if (result?.trusted === false && result.code === "EMAIL_TRUST_ENVELOPE_REFUSED")
+            return result;
+    }
+    catch { /* Do not expose policy or transport details. */ }
+    return { trusted: false, code: "EMAIL_TRUST_SETTINGS_UNAVAILABLE" };
+}

package/dist/identity/identityPersonalDataContributor.d.ts

@@ -0,0 +1,7 @@
+import type { PersonalDataObligation } from "./contracts/privacy.js";
+import { type PersonalDataContributor, type PrivacyStore } from "./privacyPorts.js";
+export interface IdentityPrivacyPolicy {
+    /** Explicit dispositions for populated opaque contact fields; absence refuses erasure. */
+    retainedContactFields: Readonly<Record<string, PersonalDataObligation>>;
+}
+export declare function createIdentityPersonalDataContributor<C>(store: PrivacyStore<C>, policy: IdentityPrivacyPolicy, randomId: () => string): PersonalDataContributor<C>;

package/dist/identity/identityPersonalDataContributor.js

@@ -0,0 +1,46 @@
+import { PrivacyRefusal } from "./privacyPorts.js";
+const owned = new Set(["id", "email", "first_name", "last_name", "phone", "country", "principal_id", "created_at", "updated_at"]);
+const populated = (value) => value !== null && value !== "" && !(typeof value === "object" && Object.keys(value).length === 0);
+export function createIdentityPersonalDataContributor(store, policy, randomId) {
+    function obligations(identity) {
+        const contact = identity.contact;
+        const result = [{ owner: "identity", resource: "identity.audit-and-receipt", disposition: "retain", reasonCode: "PSEUDONYMOUS_AUDIT", remote: false }];
+        if (contact && typeof contact === "object" && !Array.isArray(contact)) {
+            for (const [key, value] of Object.entries(contact)) {
+                if (owned.has(key) || !populated(value))
+                    continue;
+                const declaration = policy.retainedContactFields[key];
+                result.push(declaration?.disposition === "retain" && declaration.resource === `clients.${key}` ? declaration : { owner: "unassigned", resource: `clients.${key}`, disposition: "unresolved", reasonCode: "PRIVACY_OWNERSHIP_UNDECLARED", remote: false });
+            }
+        }
+        return result;
+    }
+    return {
+        id: "identity", version: "identity.personal-data.v1",
+        ownedResources: ["identity.contact-profile", "identity.principal", "identity.membership", "identity.invitations", "identity.audit-and-receipt"],
+        async prepareErasure() { },
+        async export(_context, subject) {
+            const unavailable = Array.isArray(subject.identity.unavailable) ? subject.identity.unavailable.map(String) : [];
+            const data = { ...subject.identity };
+            const contact = data.contact;
+            if (contact && typeof contact === "object" && !Array.isArray(contact)) {
+                data.contact = Object.fromEntries(Object.entries(contact).filter(([key]) => owned.has(key) || key === "auth_user_id"));
+                for (const key of Object.keys(contact))
+                    if (!owned.has(key) && key !== "auth_user_id")
+                        unavailable.push(`contact.${key}`);
+            }
+            return { contributorId: "identity", version: "identity.personal-data.v1", data,
+                coverage: { complete: unavailable.length === 0, included: Object.keys(subject.identity).filter(k => k !== "unavailable"), unavailable }, obligations: obligations(subject.identity) };
+        },
+        async assessErasure(_context, subject) {
+            const declared = obligations(subject.identity);
+            if (declared.some(o => o.disposition === "unresolved"))
+                throw new PrivacyRefusal("PRIVACY_OWNERSHIP_UNDECLARED");
+            return { obligations: declared };
+        },
+        async eraseOrRetain(context, subject, assessment, actor) {
+            await store.eraseIdentity(context, subject, actor, `erased+${randomId()}@identity.invalid`);
+            return { contributorId: "identity", version: "identity.personal-data.v1", obligations: assessment.obligations };
+        },
+    };
+}

package/dist/identity/identityReadiness.d.ts

@@ -0,0 +1,10 @@
+import type { ReadinessIssue } from "@openlup/core/readiness";
+import { type EmailTrustPolicy } from "./emailTrustPolicy.js";
+/** The module field stays structural so older core readiness types still compile; no new core code is needed. */
+export declare function identityEmailTrustReadiness(policy: EmailTrustPolicy): Promise<readonly (ReadinessIssue & {
+    module: "identity";
+})[]>;
+/** Discovery and fresh key availability are independent readiness observations. */
+export declare function identityOidcReadiness(verifier: import("./oidcIdentityVerifier.js").OidcIdentityVerifier): Promise<readonly (ReadinessIssue & {
+    module: "identity";
+})[]>;

package/dist/identity/identityReadiness.js

@@ -0,0 +1,25 @@
+import { assessEmailTrust } from "./emailTrustPolicy.js";
+/** The module field stays structural so older core readiness types still compile; no new core code is needed. */
+export async function identityEmailTrustReadiness(policy) {
+    const result = await assessEmailTrust(policy);
+    if (result.trusted)
+        return [];
+    return [{
+            code: "OPENLUP_E_PORT_MISSING", package: "@openlup/platform", module: "identity",
+            subject: "emailTrustPolicy", observation: result.code,
+            fix: result.code === "EMAIL_TRUST_ENVELOPE_REFUSED"
+                ? "Disable automatic confirmation and declare only providers that verify email."
+                : "Restore access to valid public identity settings or bind an explicit email-trust policy.",
+        }];
+}
+/** Discovery and fresh key availability are independent readiness observations. */
+export async function identityOidcReadiness(verifier) {
+    const report = await verifier.readiness();
+    if (report.state === "ready")
+        return [];
+    return [
+        ...(!report.discovery.valid ? ["oidcDiscovery"] : []),
+        ...(!report.jwks.loaded ? ["oidcJwks"] : []),
+    ].map(subject => ({ code: "OPENLUP_E_PORT_MISSING", package: "@openlup/platform", module: "identity", subject,
+        observation: report.code ?? "OIDC_JWKS_INVALID", fix: "Restore valid issuer discovery and fresh same-origin signing keys." }));
+}

package/dist/identity/index.d.ts

@@ -0,0 +1,67 @@
+export * from "./adminMagicLinkHandler.js";
+export * from "./reconcileAccountForPrincipal.js";
+export * from "./customerVerifyOtpHandler.js";
+export * from "./authVerifyUrl.js";
+export * from "./customerIdentityVerifier.js";
+export * from "./operatorTokenAdminAuth.js";
+export * from "./managedIdentityVerifier.js";
+export * from "./managedAdminAuthVerifier.js";
+export * from "./managedCustomerMe.js";
+export * from "./sql.js";
+export * from "./customerMeHandler.js";
+export * from "./messages.js";
+export * from "./managedAccountLinkStore.js";
+export * from "./customerIdentityBinding.js";
+export * from "./adminUserActionPorts.js";
+export * from "./contribution.js";
+export * from "./customerContracts.js";
+export * from "./machineActorWriteFence.js";
+export * from "./managedClient.js";
+export * from "./customerAuthorization.js";
+export * from "./customerSessionIssuer.js";
+export * from "./managedClientAuthLink.js";
+export * from "./customerAuth.js";
+export * from "./reconcileAccountHandler.js";
+export * from "./postgresCustomerMe.js";
+export * from "./ports.js";
+export * from "./postgresCustomerRecovery.js";
+export * from "./customerMagicLinkHandler.js";
+export * from "./customerSessionBinding.js";
+export * from "./adminUserHandlers.js";
+export * from "./adminPreflight.js";
+export * from "./adminAuthBinding.js";
+export * from "./customerPorts.js";
+export * from "./magicLinkPorts.js";
+export * from "./inviteAdminUserUseCase.js";
+export * from "./adminAuthorization.js";
+export * from "./removeAdminUserUseCase.js";
+export * from "./adminMeHandler.js";
+export * from "./managedAdminUserGateways.js";
+export * from "./jwtLibrary.js";
+export * from "./platformAdminAuth.js";
+export * from "./adminContracts.js";
+export * from "./contracts/emailTrust.js";
+export { createVerifierResultOnlyEmailTrustPolicy } from "./emailTrustPolicy.js";
+export type { EmailTrustAssessment, EmailTrustPolicy } from "./emailTrustPolicy.js";
+export * from "./managedEmailTrustPolicy.js";
+export * from "./identityReadiness.js";
+export * from "./operatorInvitationPorts.js";
+export * from "./operatorInvitationLifecycle.js";
+export * from "./directOperatorInvitationStore.js";
+export * from "./operatorPorts.js";
+export * from "./operatorSession.js";
+export * from "./operatorIdentityVerifier.js";
+export * from "./operatorAdminAuth.js";
+export * from "./operatorAuthHandlers.js";
+export * from "./postgresOperatorIdentity.js";
+export * from "./privacyPorts.js";
+export * from "./personalDataRegistry.js";
+export * from "./privacyUseCases.js";
+export * from "./identityPersonalDataContributor.js";
+export * from "./postgresPrivacy.js";
+export * from "./managedPrivacy.js";
+export * from "./privacyHandlers.js";
+export * from "./oidcIdentityVerifier.js";
+export * from "./oidcPrincipal.js";
+export * from "./postgresAccountLinkStore.js";
+export * from "./contracts/oidc.js";

package/dist/identity/index.js

@@ -0,0 +1,66 @@
+export * from "./adminMagicLinkHandler.js";
+export * from "./reconcileAccountForPrincipal.js";
+export * from "./customerVerifyOtpHandler.js";
+export * from "./authVerifyUrl.js";
+export * from "./customerIdentityVerifier.js";
+export * from "./operatorTokenAdminAuth.js";
+export * from "./managedIdentityVerifier.js";
+export * from "./managedAdminAuthVerifier.js";
+export * from "./managedCustomerMe.js";
+export * from "./sql.js";
+export * from "./customerMeHandler.js";
+export * from "./messages.js";
+export * from "./managedAccountLinkStore.js";
+export * from "./customerIdentityBinding.js";
+export * from "./adminUserActionPorts.js";
+export * from "./contribution.js";
+export * from "./customerContracts.js";
+export * from "./machineActorWriteFence.js";
+export * from "./managedClient.js";
+export * from "./customerAuthorization.js";
+export * from "./customerSessionIssuer.js";
+export * from "./managedClientAuthLink.js";
+export * from "./customerAuth.js";
+export * from "./reconcileAccountHandler.js";
+export * from "./postgresCustomerMe.js";
+export * from "./ports.js";
+export * from "./postgresCustomerRecovery.js";
+export * from "./customerMagicLinkHandler.js";
+export * from "./customerSessionBinding.js";
+export * from "./adminUserHandlers.js";
+export * from "./adminPreflight.js";
+export * from "./adminAuthBinding.js";
+export * from "./customerPorts.js";
+export * from "./magicLinkPorts.js";
+export * from "./inviteAdminUserUseCase.js";
+export * from "./adminAuthorization.js";
+export * from "./removeAdminUserUseCase.js";
+export * from "./adminMeHandler.js";
+export * from "./managedAdminUserGateways.js";
+export * from "./jwtLibrary.js";
+export * from "./platformAdminAuth.js";
+export * from "./adminContracts.js";
+export * from "./contracts/emailTrust.js";
+export { createVerifierResultOnlyEmailTrustPolicy } from "./emailTrustPolicy.js";
+export * from "./managedEmailTrustPolicy.js";
+export * from "./identityReadiness.js";
+export * from "./operatorInvitationPorts.js";
+export * from "./operatorInvitationLifecycle.js";
+export * from "./directOperatorInvitationStore.js";
+export * from "./operatorPorts.js";
+export * from "./operatorSession.js";
+export * from "./operatorIdentityVerifier.js";
+export * from "./operatorAdminAuth.js";
+export * from "./operatorAuthHandlers.js";
+export * from "./postgresOperatorIdentity.js";
+export * from "./privacyPorts.js";
+export * from "./personalDataRegistry.js";
+export * from "./privacyUseCases.js";
+export * from "./identityPersonalDataContributor.js";
+export * from "./postgresPrivacy.js";
+export * from "./managedPrivacy.js";
+export * from "./privacyHandlers.js";
+export * from "./oidcIdentityVerifier.js";
+export * from "./oidcPrincipal.js";
+export * from "./postgresAccountLinkStore.js";
+export * from "./contracts/oidc.js";

package/dist/identity/inviteAdminUserUseCase.d.ts

@@ -0,0 +1,89 @@
+import type { ManagedOperatorMembershipResult, OperatorInvitationConflict } from "./contracts/operatorInvitations.js";
+import type { OperatorInvitationStore } from "./operatorInvitationPorts.js";
+import { type IdentityMessages } from "./messages.js";
+export type AdminUserInviteRole = "admin" | "distributor";
+export declare const ADMIN_ROLE_NOTIFICATION_LOCALE: "en";
+export type AdminRoleNotificationSkipReason = "admin_disabled" | "egress_suppressed";
+export type InviteAdminUserResponse = {
+    [key: string]: unknown;
+    success?: boolean;
+    message?: string;
+    error?: string;
+    code?: string;
+    deliveryReference?: string | null;
+    deliveryReferencePresent?: boolean;
+};
+export interface InviteAdminUserGateway {
+    getUser: (accessToken: string) => Promise<{
+        user: {
+            id: string;
+        } | null;
+        error: unknown;
+    }>;
+    findAdminUser: (userId: string) => Promise<{
+        id: string;
+        role: string;
+        membership_state: string;
+        is_machine_actor: boolean;
+    } | null>;
+    findAdminUserByEmail: (email: string) => Promise<{
+        id: string;
+    } | null>;
+    findAuthUserByEmail: (email: string) => Promise<{
+        id: string;
+        email?: string | null;
+    } | null>;
+    inviteAuthUser: (input: {
+        email: string;
+        redirectTo: string;
+        role: AdminUserInviteRole;
+    }) => Promise<{
+        user: {
+            id: string;
+        } | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+}
+export interface AdminRoleNotificationPort {
+    sendRoleGranted: (input: {
+        email: string;
+        authUserId: string;
+        role: AdminUserInviteRole;
+        locale: "pl" | "en";
+        invitationId?: string;
+        expiresAt?: string;
+    }) => Promise<{
+        ok: boolean;
+        providerMessageId: string | null;
+        providerError: string | null;
+        skipped: boolean;
+        skipReason: AdminRoleNotificationSkipReason | null;
+    }>;
+}
+export declare function runInviteAdminUserUseCase(request: {
+    accessToken: string | null;
+    email: string;
+    role: string;
+}, deps: {
+    gateway: InviteAdminUserGateway;
+    roleNotificationPort: AdminRoleNotificationPort;
+    siteUrl: string;
+    messages?: IdentityMessages;
+    notificationLocale?: "pl" | "en";
+} & ({
+    invitationStore: OperatorInvitationStore;
+    ttlSeconds: number;
+} | {
+    activateMembership: (input: {
+        principalId: string;
+        email: string;
+        role: AdminUserInviteRole;
+    }) => Promise<ManagedOperatorMembershipResult | {
+        code: OperatorInvitationConflict;
+    }>;
+})): Promise<{
+    status: number;
+    body: InviteAdminUserResponse;
+}>;