@foir/sdk 0.20.0 → 0.22.0

package/dist/auth/operations.d.ts

@@ -1,5 +1,5 @@
 /**
- * Foir customer-auth result and input types.
+ * Foir sign-in result and input types.
  *
  * These are PLATFORM-STABLE primitives — login / register / refresh / OTP /
  * provider login / password management / account lifecycle are fixed-shape
@@ -25,15 +25,15 @@
  *     and they are the reason `@foir/sdk/auth/session` had to exist as a
  *     separate graphql-free door.
  *
- * The project-specific customer PROFILE (e.g. `myProfile.isAdmin`) is still NOT
- * here — that shape varies per project, so it stays consumer-injected (see
+ * Anything project-specific about the user (a profile record, say) is NOT
+ * here: that shape varies per project, so it stays consumer-injected (see
  * `requireAuth`'s `resolveUser`).
  */
 /** The common auth result every login/register/refresh mutation returns. */
-export interface CustomerAuthResult {
+export interface AuthResult {
     token: string;
     refreshToken: string;
-    customerId: string;
+    userId: string;
     email: string;
 }
 /** Result of initiating a provider login — a redirect URL or an inline token. */
@@ -70,7 +70,7 @@ export interface ProviderOTPVerifyInput {
     email: string;
     otp: string;
 }
-/** The project's customer signup mode. */
+/** The project's signup mode. */
 export type SignupMode = 'PUBLIC' | 'RESTRICTED' | 'WAITLIST' | 'CLOSED';
 /** The signup surface a self-hosted frontend reads to render the right UI. */
 export interface SignupContext {
@@ -93,7 +93,7 @@ export interface AuthConfigProvider {
 /**
  * The project's public auth configuration: which built-in methods are on, and
  * which external providers a login screen should offer. Readable before any
- * customer token exists — it is what a login screen renders itself from.
+ * user token exists: it is what a login screen renders itself from.
  */
 export interface AuthConfig {
     passwordEnabled: boolean;
@@ -110,8 +110,8 @@ export interface DefaultAuthProvider {
     type: string | null;
 }
 /**
- * The calling customer, resolved from the bearer token. `null` when the request
- * carried no customer token — an absent session is an answer, not a failure.
+ * The calling user, resolved from the bearer token. `null` when the request
+ * carried no user token: an absent session is an answer, not a failure.
  */
 export interface CurrentUser {
     id: string;
@@ -124,8 +124,8 @@ export interface CurrentUser {
     createdAt: string;
 }
 /**
- * A stored upstream provider token for the calling customer. `null` when there
- * is no customer token on the request, or none stored for that provider.
+ * A stored upstream provider token for the calling user. `null` when there
+ * is no user token on the request, or none stored for that provider.
  */
 export interface ProviderToken {
     providerKey: string;
@@ -142,11 +142,119 @@ export interface DeleteAccountResult {
     recordsDeleted: number;
     filesDeleted: number;
 }
+/** The calling user's own profile, as `updateMyProfile` answers it. */
+export interface MyProfile {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    avatarUrl: string | null;
+    /** BCP47, or null where they follow the project default. */
+    preferredLocale: string | null;
+}
 /**
- * One organization the calling operator may stand in, as `myOrganizations`
+ * What `updateMyProfile` changes. A field left out stays as it is; an empty
+ * string clears it.
+ */
+export type MyProfileChange = {
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    /** A locale the project publishes. */
+    preferredLocale?: string;
+};
+/** Somewhere the calling user is signed in, or a personal access token they hold. */
+export interface MySession {
+    /** The session's handle, which {@link endMySession} takes. It signs nobody in. */
+    id: string;
+    /** `browser` for a sign-in, `personal_access_token` for a token. */
+    kind: string;
+    /** A personal access token's name. */
+    name: string | null;
+    /** The first characters of a personal access token's value. */
+    tokenPrefix: string | null;
+    /** The app it was signed in through. */
+    appName: string | null;
+    /** ISO-8601. */
+    createdAt: string | null;
+    /** ISO-8601. */
+    lastSeenAt: string | null;
+    /** ISO-8601. */
+    expiresAt: string | null;
+    ipAddress: string | null;
+    userAgent: string | null;
+    /** Whether it is the session making the request. */
+    current: boolean;
+}
+/** A personal access token just made: its value is shown here once. */
+export interface NewPersonalAccessToken {
+    token: MySession;
+    value: string;
+}
+/** A provider the calling user signs in with. */
+export interface MySignInMethod {
+    provider: string;
+    /** The address the provider gave when it was connected. */
+    email: string | null;
+    /** ISO-8601. */
+    connectedAt: string | null;
+}
+/** A second factor, passkey or set of recovery codes the calling user holds. */
+export interface MyFactor {
+    /** `totp`, `security_key`, `passkey` or `recovery_codes`. */
+    kind: string;
+    /** What {@link removeFactor} takes. */
+    id: string;
+    /** A security key's or passkey's name. */
+    name: string | null;
+    /** ISO-8601. */
+    addedAt: string | null;
+    /** For recovery codes: how many are left unused. */
+    remaining: number | null;
+}
+/**
+ * A step-up begun with the calling user's password: waiting for a second
+ * factor, or, for a user who holds none, already proven by the password.
+ */
+export interface StepUp {
+    /** What {@link completeStepUp} takes, for a user who holds a second factor. */
+    handle: string | null;
+    /** For a user who holds no second factor: the proof their password is, for one change to their factors. */
+    elevatedHandle: string | null;
+    /** Whether a security key or passkey can prove it. */
+    webauthn: boolean;
+    /** Whether an authenticator app's code can prove it. */
+    totp: boolean;
+    /** The publicKey options for `navigator.credentials.get`, as JSON. */
+    webauthnOptionsJson: string | null;
+}
+/** A second factor being added, waiting for the browser or the authenticator app. */
+export interface FactorEnrollment {
+    /** What {@link completeFactorEnrollment} takes. */
+    handle: string;
+    /** For a security key or passkey: the publicKey options for `navigator.credentials.create`, as JSON. */
+    webauthnOptionsJson: string | null;
+    /** For an authenticator app: the key to enter by hand. */
+    totpSecret: string | null;
+    /** For an authenticator app: a QR code of the key, as a data URI. */
+    totpQr: string | null;
+}
+/** An app the calling user has agreed may act for them. */
+export interface AuthorizedApp {
+    /** The consent's id, which {@link revokeAuthorizedApp} takes. */
+    id: string;
+    clientId: string;
+    clientName: string;
+    /** What the app may carry for them, in the permission catalogue's names. */
+    grants: string[];
+    /** ISO-8601. */
+    grantedAt: string | null;
+}
+/**
+ * One organization the calling user may stand in, as `myOrganizations`
  * returns it.
  *
- * Identity, not configuration: the id to hand to {@link selectOrganization}, a
+ * Identity, not configuration: the id a request names to act there, a
  * name to render, the status, and where it sits. Only active organizations are
  * returned today; `status` is here so that a widening is visible to the caller
  * rather than silent.
@@ -157,7 +265,7 @@ export interface DeleteAccountResult {
  * this surface's to hand out.
  *
  * THE LIST IS A SUBTREE. A membership at an organization reaches everything
- * beneath it, so an operator who runs a group is offered the group and every
+ * beneath it, so someone who runs a group is offered the group and every
  * client under it. Draw it flat and a reseller's clients render as its
  * siblings, which is what the three position fields are for.
  */
@@ -168,7 +276,7 @@ export interface MyOrganization {
     /**
      * The immediate parent, or null for a root.
      *
-     * A root OF THE PROJECT, not of the caller's view: an operator whose
+     * A root OF THE PROJECT, not of the caller's view: a member whose
      * membership sits three levels down sees their own organization with a parent
      * they cannot read. Null means there is no parent; it is never the empty
      * string, because that is a third value with no reading.
@@ -179,16 +287,16 @@ export interface MyOrganization {
      * project root.
      *
      * IDS, not names, and the whole path — including ancestors this caller cannot
-     * read. An id is disclosed to everything below it; a name is row content an
-     * operator further down may not be entitled to. A path trimmed to the
-     * readable ancestors would have gaps or a false root, and two operators of
+     * read. An id is disclosed to everything below it; a name is row content a
+     * member further down may not be entitled to. A path trimmed to the
+     * readable ancestors would have gaps or a false root, and two members of
      * one organization would then see different paths to it.
      */
     ancestorIds: string[];
     /**
      * Levels above this organization in the PROJECT's tree: 0 is a project root.
      *
-     * The project's depth rather than the caller's, so two operators looking at
+     * The project's depth rather than the caller's, so two members looking at
      * the same organization agree about where it is. Indent by the difference
      * from the shallowest entry in the list if you want the caller's own view.
      */
@@ -197,7 +305,7 @@ export interface MyOrganization {
      * The caller's own role in this organization, or null when their
      * membership carries none (or a disabled one). Never another member's role.
      *
-     * ONE ROLE, NOT THE WHOLE AUTHORITY. The platform resolves the operator's
+     * ONE ROLE, NOT THE WHOLE AUTHORITY. The platform resolves the member's
      * authority per request as the union of the roles on every membership that
      * reaches this organization (one held in it and every one held above it),
      * together with their own roles in the project. This field is the role of
@@ -219,15 +327,3 @@ export interface MyOrganizationRole {
      */
     grants: string[];
 }
-/**
- * Where the caller now stands, as `selectMyOrganization` returns it.
- *
- * Two fields, because two are all there is to say. It is NOT a session context:
- * an operator is a customer, and the platform's admin session shape — user,
- * available tenants, effective permissions — describes a population this level
- * exists to keep them out of.
- */
-export interface SelectedOrganization {
-    orgId: string;
-    orgName: string;
-}

package/dist/auth/ops.d.ts

@@ -41,37 +41,55 @@ export declare const AUTH_OPS: {
     readonly authConfig: "authConfig";
     readonly authProviders: "authProviders";
     readonly defaultAuthProvider: "defaultAuthProvider";
-    readonly customerSignupContext: "customerSignupContext";
+    readonly signupContext: "signupContext";
     readonly currentUser: "currentUser";
     readonly myProviderToken: "myProviderToken";
     readonly whoami: "whoami";
-    readonly customerLogin: "customerLogin";
-    readonly customerRegister: "customerRegister";
-    readonly customerRequestOTP: "customerRequestOTP";
-    readonly customerLoginOTP: "customerLoginOTP";
-    readonly customerRefreshToken: "customerRefreshToken";
-    readonly customerLogout: "customerLogout";
-    readonly customerJoinWaitlist: "customerJoinWaitlist";
-    readonly customerRequestPasswordReset: "customerRequestPasswordReset";
-    readonly customerResetPassword: "customerResetPassword";
-    readonly customerUpdatePassword: "customerUpdatePassword";
-    readonly customerVerifyEmail: "customerVerifyEmail";
+    readonly login: "login";
+    readonly register: "register";
+    readonly requestOTP: "requestOTP";
+    readonly loginWithOTP: "loginWithOTP";
+    readonly refreshToken: "refreshToken";
+    readonly logout: "logout";
+    readonly joinWaitlist: "joinWaitlist";
+    readonly requestPasswordReset: "requestPasswordReset";
+    readonly resetPassword: "resetPassword";
+    readonly updatePassword: "updatePassword";
+    readonly verifyEmail: "verifyEmail";
     readonly deleteMyAccount: "deleteMyAccount";
+    readonly updateMyProfile: "updateMyProfile";
+    readonly myAuthorizedApps: "myAuthorizedApps";
+    readonly revokeAuthorizedApp: "revokeAuthorizedApp";
+    readonly mySessions: "mySessions";
+    readonly endMySession: "endMySession";
+    readonly signOutEverywhere: "signOutEverywhere";
+    readonly createPersonalAccessToken: "createPersonalAccessToken";
+    readonly mySignInMethods: "mySignInMethods";
+    readonly connectSignInMethod: "connectSignInMethod";
+    readonly disconnectSignInMethod: "disconnectSignInMethod";
+    readonly myFactors: "myFactors";
+    readonly beginStepUp: "beginStepUp";
+    readonly completeStepUp: "completeStepUp";
+    readonly beginFactorEnrollment: "beginFactorEnrollment";
+    readonly completeFactorEnrollment: "completeFactorEnrollment";
+    readonly removeFactor: "removeFactor";
+    readonly makeRecoveryCodes: "makeRecoveryCodes";
     readonly myOrganizations: "myOrganizations";
-    readonly selectMyOrganization: "selectMyOrganization";
-    readonly registerOperatorOrganization: "registerOperatorOrganization";
-    readonly customerLoginWithProvider: "customerLoginWithProvider";
-    readonly customerProviderCallback: "customerProviderCallback";
-    readonly customerProviderVerifyOTP: "customerProviderVerifyOTP";
+    readonly registerOrganization: "registerOrganization";
+    readonly loginWithProvider: "loginWithProvider";
+    readonly providerCallback: "providerCallback";
+    readonly providerVerifyOTP: "providerVerifyOTP";
+    readonly confirmProviderLink: "confirmProviderLink";
+    readonly resendProviderLinkCode: "resendProviderLinkCode";
 };
 /** One of the auth namespace's root field names. */
 export type AuthOpName = (typeof AUTH_OPS)[keyof typeof AUTH_OPS];
 /** Per-call overrides for an auth op. */
 export interface AuthOpOptions {
     /**
-     * Customer bearer token. api-public still needs the `x-api-key` to resolve
-     * the project; the bearer adds the customer identity the post-credential ops
-     * (`currentUser`, `customerUpdatePassword`, `deleteMyAccount`, …) are
+     * User bearer token. api-public still needs the `x-api-key` to resolve
+     * the project; the bearer adds the user identity the post-credential ops
+     * (`currentUser`, `updatePassword`, `deleteMyAccount`, …) are
      * authorised by. Ignored by the pre-credential ops, which mint it.
      */
     bearerToken?: string;
@@ -85,7 +103,7 @@ export interface AuthOpOptions {
     /**
      * The organization the call acts in, named by the address of the page it is
      * for, sent as `X-Org-Url`: same contract as `FoirClientConfig.orgUrl`. A
-     * storefront on a path per organization signs its customers in on those
+     * storefront on a path per organization signs its users in on those
      * pages, and names the organization the way every other request from them
      * does.
      */

package/dist/auth/session-client.d.ts

@@ -19,7 +19,7 @@
  * There is no refresh token in this flow. Re-exchanging the cookie IS the
  * refresh, which is why nothing here needs rotation or reuse-detection: the
  * durable credential is an opaque server-side session handle, revocable at any
- * time from the admin panel or `signOut()`.
+ * time from the console or `signOut()`.
  *
  * REQUIRES a verified custom login domain that shares a registrable domain with
  * your app (app.acme.com + login.acme.com). That is what makes the cookie
@@ -47,7 +47,7 @@ export interface FoirSessionConfig {
 }
 /** The identity behind the current session. */
 export interface FoirSessionUser {
-    customerId: string;
+    userId: string;
     email: string;
 }
 export interface FoirSessionClient {
@@ -57,7 +57,7 @@ export interface FoirSessionClient {
      * exchange. Call this before each API request — do not cache the result.
      */
     getToken(): Promise<string | null>;
-    /** The signed-in customer, or null. Exchanges if the session isn't loaded yet. */
+    /** The signed-in user, or null. Exchanges if the session isn't loaded yet. */
     getUser(): Promise<FoirSessionUser | null>;
     /** Revoke the session server-side and clear the cookie. Idempotent. */
     signOut(): Promise<void>;

package/dist/auth-session.js

@@ -64,14 +64,14 @@ function createFoirSessionClient(config) {
       } catch {
         return cached;
       }
-      if (!json.access_token || !json.customer_id) return cached;
+      if (!json.access_token || !json.user_id) return cached;
       const expiresIn = typeof json.expires_in === "number" ? json.expires_in : 0;
       const next = {
         token: json.access_token,
         expiresAt: Date.now() + expiresIn * 1e3,
-        user: { customerId: json.customer_id, email: json.email ?? "" }
+        user: { userId: json.user_id, email: json.email ?? "" }
       };
-      const changed = cached?.user.customerId !== next.user.customerId;
+      const changed = cached?.user.userId !== next.user.userId;
       cached = next;
       scheduleRefresh(next.expiresAt);
       if (changed) emit(next.user);