palbase 0.17.1 → 0.18.1

package/types/internal/src/modules/stores.d.ts

@@ -467,6 +467,10 @@ export type AppleChangedEvent = {
      * What Apple said of the key (connected, checked).
      */
     status?: "active" | "agreement" | "refused";
+    /**
+     * The key was made at Apple by Palbase, with the environment's Apple ID session (connected).
+     */
+    made?: boolean;
 };
 /**
  * A one-time grant to connect an Apple key: the key goes from the person's browser (connect_url) or terminal (POST /stores/connect with the grant) straight to the module.
@@ -2532,6 +2536,7 @@ export type AppleSession = {
      */
     status?: "active" | "expired";
     team?: AppleTeam;
+    shared_from?: SharedEnvironment;
 };
 /**
  * stores.apple.session.changed: an Apple ID was signed in for the project, or disconnected. Never the session.
@@ -2885,6 +2890,125 @@ export type AppleSessionEndedEvent = {
      */
     connected_by: string;
 };
+/**
+ * A key Palbase made at Apple for the environment: never its .p8.
+ */
+export type MadeKey = {
+    /**
+     * The apps it is for (APNs, In-App Purchase).
+     */
+    bundles?: string[];
+    /**
+     * An APNs key's environment.
+     */
+    environment?: "sandbox" | "prod";
+    /**
+     * The key's id at Apple.
+     */
+    key_id: string;
+    /**
+     * `asc` (App Store Connect API), `apns` or `iap` (In-App Purchase).
+     */
+    kind: "asc" | "apns" | "iap";
+    /**
+     * When it was made.
+     */
+    made_at: string;
+    /**
+     * Who asked for it: a developer's id, or the key's.
+     */
+    made_by: string;
+    /**
+     * The module it is for: notify (APNs), purchases (In-App Purchase).
+     */
+    module?: "notify" | "purchases";
+    /**
+     * What became of it, when it was not simply taken.
+     */
+    note?: string;
+    /**
+     * When its module took it, refused it, or it was revoked.
+     */
+    settled_at?: string;
+    /**
+     * `waiting` for its module to take it, `taken`, `refused` (its module keeps a key of its own and it could not be revoked at Apple), or `revoked`.
+     */
+    state: "waiting" | "taken" | "refused" | "revoked";
+};
+/**
+ * Keys Palbase made at Apple for the environment.
+ */
+export type MadeKeys = {
+    keys: MadeKey[];
+};
+/**
+ * The key to make at Apple.
+ */
+export type MakeKeyRequest = {
+    /**
+     * The iOS app an In-App Purchase key is for; required when the environment has more than one.
+     */
+    bundle?: string;
+    /**
+     * `asc` (App Store Connect API), `apns` or `iap` (In-App Purchase).
+     */
+    kind: "asc" | "apns" | "iap";
+};
+/**
+ * The environment of the organization whose Apple ID session the project uses, having none of its own: signed in to the project's App Store Connect team.
+ */
+export type SharedEnvironment = {
+    /**
+     * Its project's name.
+     */
+    name?: string;
+    /**
+     * Its platform project's id.
+     */
+    project_id: string;
+    /**
+     * Its ref.
+     */
+    ref?: string;
+};
+/**
+ * stores.apple.key.made: keys were made at Apple for another module of the environment (notify's APNs keys, purchases' In-App Purchase key), which takes them. Never a key.
+ */
+export type AppleKeyMadeEvent = {
+    /**
+     * The keys' handover: what the module takes at once.
+     */
+    handover: string;
+    /**
+     * The keys' ids at Apple.
+     */
+    key_ids: string[];
+    /**
+     * `apns` or `iap`.
+     */
+    kind: "apns" | "iap";
+    /**
+     * The module the keys are for.
+     */
+    module: "notify" | "purchases";
+};
+/**
+ * stores.apple.key.revoked: a key Palbase made at Apple for the environment was revoked there. Never the key.
+ */
+export type AppleKeyRevokedEvent = {
+    /**
+     * The key's id at Apple.
+     */
+    key_id: string;
+    /**
+     * `apns` or `iap`.
+     */
+    kind: "asc" | "apns" | "iap";
+    /**
+     * The module it was for.
+     */
+    module?: string;
+};
 /** The events this module sends the project's webhooks (x-palbase-events), by type: each one's payload, the event's data. */
 export interface Events {
     /**
@@ -2971,6 +3095,14 @@ export interface Events {
      * stores.apple.session.ended: Palbase's own project's copy of an Apple ID session Apple ended in a customer's project, whose Studio mails the person who connected it.
      */
     "stores.apple.session.ended": AppleSessionEndedEvent;
+    /**
+     * stores.apple.key.made: keys were made at Apple for another module of the environment (notify's APNs keys, purchases' In-App Purchase key), which takes them. Never a key.
+     */
+    "stores.apple.key.made": AppleKeyMadeEvent;
+    /**
+     * stores.apple.key.revoked: a key Palbase made at Apple for the environment was revoked there. Never the key.
+     */
+    "stores.apple.key.revoked": AppleKeyRevokedEvent;
 }
 /** Palbase Stores */
 export declare function client(t: Transport): {
@@ -3914,5 +4046,39 @@ export declare function client(t: Transport): {
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<204, undefined>>;
+    /**
+     * Keys made at Apple
+     *
+     * The keys Palbase made at Apple for the environment with its Apple ID session (`POST /stores/apple/keys`), the newest first — never a key itself: its App Store Connect API key, its APNs keys (notify's) and its In-App Purchase key (purchases'), and where each stands.
+     */
+    listMadeAppleKeys(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MadeKeys>>;
+    /**
+     * Make a key at Apple
+     *
+     * Makes one key at Apple with the Apple ID session the environment uses, and connects it: no one downloads a .p8. `asc` — the environment's App Store Connect API key (Admin, every app), connected as `POST /stores/connect` connects one (409 `key_connected` when one is). `apns` — two APNs keys, one for each APNs environment (Apple makes a key scoped to apps for one environment), scoped to the environment's iOS apps, which the notify module takes as its APNs provider. `iap` — an In-App Purchase key for one of its iOS apps (`bundle`, required with more than one), which the purchases module connects. A module that keeps a key the environment connected itself refuses the one made, and it is revoked at Apple. One a request (each well inside the edge's time); 409 `key_made` for a kind Palbase made already. The Apple ID must be an Admin or the Account Holder (409 `apple_role_insufficient`). An owner's or an admin's, or the project's secret key's (403 `admin_required` for a member); never an environment's token's (403 `token_out_of_scope`): a key outlives it. Emits `stores.apple.changed` (asc) or `stores.apple.key.made` (apns, iap).
+     */
+    makeAppleKey(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: MakeKeyRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, MadeKeys>>;
+    /**
+     * Revoke a key made at Apple
+     *
+     * Revokes at Apple an APNs or In-App Purchase key Palbase made for the environment: its module keeps it, and it no longer works. The App Store Connect key is revoked as it is disconnected (`DELETE /stores/apple`; 409 `key_connected` here). An owner's or an admin's, or the project's secret key's. Emits `stores.apple.key.revoked`.
+     */
+    revokeMadeAppleKey(input: {
+        path: {
+            key_id: string;
+        };
+        headers?: {
+            "Idempotency-Key"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MadeKey>>;
 };
 export type Client = ReturnType<typeof client>;

package/types/web/src/auth.d.ts

@@ -1,6 +1,6 @@
 import { auth as authModule } from '../../internal/src/modules/index.js';
 import type { Transport } from '../../internal/src/transport.js';
-import type { AuthEvent, Session, SessionEndReason, SessionManager } from './session.js';
+import { type AuthEvent, type Session, type SessionEndReason, type SessionManager } from './session.js';
 type A = typeof authModule;
 export type User = authModule.User;
 export type SignupRequest = authModule.SignupRequest;
@@ -62,6 +62,13 @@ export declare class Auth {
         /** Removes a factor; the account's password confirms it. */
         removeFactor: (id: string, currentPassword: string) => Promise<void>;
         regenerateRecoveryCodes: () => Promise<authModule.MFARecoveryCodesResponse>;
+        /**
+         * Raises the signed-in session to aal2 with a code the authenticator app
+         * shows — what a route marked auth { aal: 'aal2' } asks for (401
+         * insufficient_user_authentication). The session holds the new token from
+         * here on; its refreshes stay at aal2.
+         */
+        stepUp: (code: string) => Promise<Session>;
     };
     readonly passkey: {
         /** Adds a passkey to the signed-in user. */
@@ -79,6 +86,8 @@ export declare class Auth {
          * it (the sign-up answers no tokens). The identifier is the user's email.
          */
         signUp: (identifier: string, userName?: string) => Promise<User>;
+        /** Raises the signed-in session to aal2 with one of the user's passkeys (as mfa.stepUp does with a code). */
+        stepUp: () => Promise<Session>;
         list: () => Promise<authModule.WebAuthnCredentialList>;
         remove: (id: string) => Promise<void>;
     };
@@ -156,6 +165,7 @@ export declare class Auth {
     }): Promise<User>;
     /** Starts the session from a token pair; the user is the answer's, or read once when it carries none. */
     private signedIn;
+    private steppedUp;
     private authenticator;
 }
 type Json = Record<string, unknown>;

package/types/web/src/client.d.ts

@@ -10,6 +10,7 @@ import { Notify } from './notify.js';
 import { Purchases } from './purchases.js';
 import { type ChatToolCall } from './chat.js';
 import { Flags } from './flags.js';
+import { Messaging, type MessagingOptions } from './messaging.js';
 export interface ClientOptions {
     /** The project's address: https://<ref>.<domain> */
     url: string;
@@ -68,6 +69,8 @@ export interface ClientOptions {
      * pb.setLanguage changes it.
      */
     language?: string | readonly string[];
+    /** What the device keeps of the signed-in person's conversations (pb.messaging): dropped on sign-out unless keepOnSignOut. */
+    messaging?: MessagingOptions;
 }
 /**
  * The app's client. A backend's generated Palbe module (palbase apps:sync)
@@ -93,6 +96,8 @@ export interface PalbaseClient {
     notify: Notify;
     /** The project's feature flags and remote configuration, resolved for this app and its reader, kept current as they change. */
     flags: Flags;
+    /** The signed-in person's conversations — direct ones and groups — kept up to date, on the device and live. */
+    messaging: Messaging;
     /** The language every request says from now on (ClientOptions.language); null for the browser's own. */
     setLanguage(language: string | readonly string[] | null): void;
     /**

package/types/web/src/index.d.ts

@@ -10,6 +10,7 @@ export { connectVoice, type StartedVoice, type VoiceConnection, type VoiceOption
 export { Purchases, redemptionToken, type CheckoutSource, type CustomerInfo, type CustomerInfoListener, type GrantInfo, type MergeGrant, type OfferView, type Offerings, type Redeemed, type RedemptionLink, } from './purchases.js';
 export { Notify, WebPush, type PushPermission, type PushSubscribeOptions } from './notify.js';
 export { Flags, type FlagSource, type FlagsListener } from './flags.js';
+export { ConversationList, ConversationView, indexedDBKeyValue, Messaging, ScheduledList, ThreadView, type Conversation, type ConversationViewState, type ConversationListState, type Entry, type Member, type Message, type MessagingOptions, type MyProfile, type Observed, type OpenedFile, type OutboxItem, type OutgoingFile, type Profile, type ScheduledMessage, type SendOptions, type ThreadState, type ThreadViewState, } from './messaging.js';
 export { Inbox, type InboxItem, type InboxListOptions, type InboxPage, type InboxView, type InboxViewOptions } from './inbox.js';
 export { InApp, SESSION_START, type InAppOptions } from './inapp.js';
 export type { Paywall, PaywallRenderOptions } from './paywall/placement.js';

package/types/web/src/messaging.d.ts

@@ -0,0 +1,280 @@
+import { messaging as api } from '../../internal/src/modules/index.js';
+import { Engine, type Entry, type KeyValue, type OutboxItem, type Touched } from '../../internal/src/messaging/index.js';
+import { type Fetch, type Transport } from '../../internal/src/transport.js';
+import { type SessionManager } from './session.js';
+import type { RealtimeSocket } from './socket.js';
+export type Conversation = api.Conversation;
+export type Message = api.Message;
+export type Member = api.Member;
+export type MyProfile = api.MyProfile;
+export type Profile = api.Profile;
+export type ScheduledMessage = api.ScheduledMessage;
+export type ThreadState = api.ThreadState;
+export type { Entry, OutboxItem } from '../../internal/src/messaging/index.js';
+export interface MessagingOptions {
+    /**
+     * What the device keeps of a person's conversations when they sign out:
+     * dropped unless true — then it is theirs again when they come back, and
+     * no one else who signs in on the device reads it.
+     */
+    keepOnSignOut?: boolean;
+    /** Where the device keeps it: IndexedDB in a browser, memory where there is none, unless given. */
+    storage?: KeyValue;
+}
+/** A file to send: its bytes are encrypted on the device before they are uploaded. */
+export interface OutgoingFile {
+    data: Blob | Uint8Array;
+    contentType: string;
+    name?: string;
+    width?: number;
+    height?: number;
+    durationMs?: number;
+    /** A small preview the app makes (a blurhash, a tiny data URL): sealed in the message, as the file's key is. */
+    thumbnail?: string;
+}
+export interface SendOptions {
+    text?: string;
+    mentions?: api.Mention[];
+    /** The message it answers inline. */
+    replyTo?: string;
+    /** The message whose thread it answers in. */
+    threadId?: string;
+    /** A thread's answer the conversation's timeline shows too. */
+    alsoInConversation?: boolean;
+    files?: OutgoingFile[];
+    /** Seconds it lives: from when it is sent, or (expiresFrom 'read') from when everyone it was for read it. */
+    expiresIn?: number;
+    expiresFrom?: 'send' | 'read';
+    /** Its files are seen a limited number of times: once (1) or once more (2), each for seconds at most. */
+    viewOnce?: {
+        limit: 1 | 2;
+        seconds?: number;
+    };
+    /** Sent then, by the server, the person's device off or not. */
+    sendAt?: Date;
+}
+/** A file opened: its bytes, decrypted on the device. */
+export interface OpenedFile {
+    id: string;
+    name: string | null;
+    contentType: string;
+    bytes: Uint8Array;
+}
+type Listener = () => void;
+/** Something that keeps itself up to date: state, and a way to hear it change. */
+export interface Observed<S> {
+    readonly state: S;
+    subscribe(listener: Listener): () => void;
+}
+export interface ConversationListState {
+    /** The person's conversations, the latest first. */
+    items: Conversation[];
+    /** How many messages they have not read, across them. */
+    unread: number;
+    /** The device's copy was drawn and the sync has caught up. */
+    synced: boolean;
+}
+export interface ConversationViewState {
+    conversation: Conversation | null;
+    /** Its timeline: its messages, the oldest first, then what is on its way. */
+    entries: Entry[];
+    members: Member[];
+    /** Who is typing now, by user id. */
+    typing: string[];
+    /** Older messages are there to read (loadEarlier). */
+    hasEarlier: boolean;
+}
+export interface ThreadViewState {
+    root: Message | null;
+    entries: Entry[];
+    thread: ThreadState | null;
+}
+/** Where a browser keeps it: IndexedDB, one object store of each person's state. */
+export declare function indexedDBKeyValue(name?: string): KeyValue | null;
+type Client = ReturnType<typeof api.client>;
+export declare class Messaging {
+    /** The module's API with whoever is signed in now: everything the views do not. */
+    readonly api: Client;
+    private readonly local;
+    private readonly transportFor;
+    /** Each person's API: what is done for one — what they wrote, what they read — never goes with another's token. */
+    private readonly clients;
+    private user;
+    private engine;
+    private starting;
+    private channel;
+    private off;
+    private readonly heard;
+    private synced;
+    private syncing;
+    private resync;
+    private flushing;
+    private reflush;
+    private retries;
+    private timers;
+    private readonly delivered;
+    private readonly expiring;
+    private readonly typingBy;
+    private readonly typedAt;
+    private readonly loaded;
+    private readonly earlier;
+    private saving;
+    private readonly reopeners;
+    private readonly incoming;
+    private readonly session;
+    private readonly socket;
+    private readonly ref;
+    private readonly fetchFn;
+    private readonly opts;
+    constructor(transport: Transport, transportFor: (user: string) => Transport, session: SessionManager, socket: RealtimeSocket, ref: string, fetchFn: Fetch, opts?: MessagingOptions);
+    /**
+     * Starts following the signed-in person's conversations — the views do it
+     * themselves: the device's copy first, then the person's channel and the
+     * sync. Rejects when no one is signed in.
+     */
+    ready(): Promise<Engine>;
+    /** The person signed out (or another signed in): what the device keeps is dropped unless kept, and nothing of theirs is followed. */
+    private end;
+    private unfollow;
+    private follow;
+    /** The app is back (online, in view): catch up and send what waits. */
+    private wake;
+    /** Reads what changed since the cursor the device holds, until nothing is left. */
+    sync(): Promise<void>;
+    /**
+     * Tells the app of a message someone else wrote, as it comes live — what an app shows a banner of while it is in
+     * front (its pushes are not shown then): once, never what a sync or a page reads, an edit, a removal or the
+     * person's own. Returns the unsubscribe.
+     */
+    onIncoming(listener: (m: Message) => void): () => void;
+    private heardLive;
+    /** Applies what changed to the person's conversations — to e's alone: what came for one who is gone goes nowhere. */
+    private changed;
+    /** What follows a change: timers to take messages away, deliveries told, the device's copy saved. */
+    private after;
+    /** A message whose time is up goes from the device at once: the server says so too, a moment after. */
+    private expireAt;
+    private deliver;
+    private save;
+    /** Sends what waits, in each conversation's order; tries again later while the network or the server is away. */
+    flush(): Promise<void>;
+    /** Sends one message with its writer's token — none other: signed out meanwhile, it waits for them. */
+    private post;
+    private presence;
+    private as;
+    /** The signed-in person's place: what is done for them goes with their token, and comes back to them alone. */
+    private seat;
+    private typed;
+    private tell;
+    /** The person's conversations, the latest first, kept up to date. */
+    conversations(): ConversationList;
+    /** A conversation of the person's, kept up to date: its timeline, its members, who is typing. */
+    conversation(conversationId: string): ConversationView;
+    /** The direct conversation with someone — the one there is, or a new one. */
+    direct(userId: string): Promise<ConversationView>;
+    /** A new group, the person its owner. */
+    group(input: {
+        title: string;
+        memberIds?: string[];
+        description?: string;
+        photo?: string;
+        settings?: api.GroupSettings;
+    }): Promise<{
+        conversation: ConversationView;
+        notAdded: api.NotAdded[];
+    }>;
+    /** A thread: a message's answers, kept up to date. */
+    thread(conversationId: string, rootId: string): ThreadView;
+    /** The person's messages scheduled for later, kept up to date. */
+    scheduled(): ScheduledList;
+    /** The threads the person follows, the latest answered first. */
+    threads(): Promise<api.ThreadItem[]>;
+    /** Writes a message: drawn at once, sent now or once the network is back — once. A message for later is in scheduled(). */
+    send(conversationId: string, input: string | SendOptions): Promise<OutboxItem>;
+    /** Each file encrypted with a key of its own, uploaded: what a message carries of them. */
+    private upload;
+    /** A file of a message, downloaded and decrypted on the device. A message seen once gives its files by viewOnce alone. */
+    open(message: Message, attachmentId: string): Promise<OpenedFile>;
+    /** Opens a message seen a limited number of times: its files, decrypted — held by the app, never by the device. */
+    viewOnce(message: Message): Promise<OpenedFile[]>;
+    private bytes;
+    edit(conversationId: string, messageId: string, text: string, mentions?: api.Mention[]): Promise<Message>;
+    /** Removes a message: for everyone (its writer, within 48 hours; a group's admin) or for the person alone. */
+    remove(conversationId: string, messageId: string, scope?: 'everyone' | 'me'): Promise<void>;
+    /** Reacts with an emoji, beside the person's other reactions (replace: in their place). */
+    react(conversationId: string, messageId: string, emoji: string, opts?: {
+        replace?: boolean;
+    }): Promise<Message>;
+    unreact(conversationId: string, messageId: string, emoji: string): Promise<Message>;
+    /** The person read a conversation up to seq (its last message unless given): their unread count goes, and the others see it unless reads are hidden. */
+    markRead(conversationId: string, seq?: number, threadId?: string): Promise<void>;
+    /** The person is typing: told to the others, at most every two seconds. */
+    typing(conversationId: string, threadId?: string): Promise<void>;
+    /** Changes a conversation: its title, picture, timer, vanish mode, policies. */
+    update(conversationId: string, change: api.UpdateConversation): Promise<Conversation>;
+    /** The person leaves a conversation in vanish mode: what they read in it goes. */
+    close(conversationId: string): Promise<void>;
+    /** The person took a screenshot of a conversation: the others are told (an app on a phone knows it; a browser does not). */
+    screenshot(conversationId: string): Promise<Message>;
+    leave(conversationId: string): Promise<void>;
+    deleteConversation(conversationId: string): Promise<void>;
+    notifications(conversationId: string, change: api.NotificationsRequest): Promise<void>;
+    cancelScheduled(id: string): Promise<void>;
+    editScheduled(id: string, change: api.UpdateScheduled): Promise<ScheduledMessage>;
+    me(): Promise<MyProfile>;
+    /** Changes the person's profile and settings: name, picture, last seen, read receipts, the timer of conversations they open. */
+    updateMe(change: api.UpdateProfile): Promise<MyProfile>;
+    profiles(userIds: string[]): Promise<Profile[]>;
+    block(userId: string): Promise<void>;
+    unblock(userId: string): Promise<void>;
+    report(input: api.ReportRequest): Promise<api.ReportCreated>;
+}
+declare abstract class View<S> implements Observed<S> {
+    protected listeners: Set<Listener>;
+    private unlisten;
+    private unperson;
+    private cached;
+    protected readonly m: Messaging;
+    constructor(m: Messaging);
+    /** What it is now: kept while it is subscribed, read again each time when not. */
+    get state(): S;
+    subscribe(listener: Listener): () => void;
+    protected opened(): void;
+    protected abstract touches(t: Touched): boolean;
+    protected abstract read(): S;
+}
+export declare class ConversationList extends View<ConversationListState> {
+    protected touches(t: Touched): boolean;
+    protected read(): ConversationListState;
+}
+export declare class ConversationView extends View<ConversationViewState> {
+    readonly id: string;
+    constructor(m: Messaging, id: string);
+    protected opened(): void;
+    protected touches(t: Touched): boolean;
+    protected read(): ConversationViewState;
+    /** Reads the conversation's newest page now (opening it does). */
+    refresh(): Promise<boolean>;
+    /** Reads the page of messages before the oldest one drawn; answers whether there are more. */
+    loadEarlier(): Promise<boolean>;
+    send(input: string | SendOptions): Promise<OutboxItem>;
+    markRead(seq?: number): Promise<void>;
+    typing(): Promise<void>;
+    thread(rootId: string): ThreadView;
+}
+export declare class ThreadView extends View<ThreadViewState> {
+    readonly conversationId: string;
+    readonly rootId: string;
+    constructor(m: Messaging, conversationId: string, rootId: string);
+    protected opened(): void;
+    protected touches(t: Touched): boolean;
+    protected read(): ThreadViewState;
+    /** Answers in the thread (alsoInConversation: the conversation's timeline shows it too). */
+    send(input: string | Omit<SendOptions, 'threadId'>): Promise<OutboxItem>;
+    markRead(): Promise<void>;
+}
+export declare class ScheduledList extends View<ScheduledMessage[]> {
+    protected opened(): void;
+    protected touches(t: Touched): boolean;
+    protected read(): ScheduledMessage[];
+}