@eulab/connect 0.8.0 → 0.10.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/INTEGRATION.md +176 -0
- package/README.md +35 -1
- package/dist/application-store.d.ts +33 -0
- package/dist/application-store.js +68 -0
- package/dist/application.d.ts +212 -0
- package/dist/application.js +406 -0
- package/dist/browser.d.ts +14 -2
- package/dist/browser.js +10 -0
- package/dist/functions.d.ts +58 -0
- package/dist/server.d.ts +149 -2
- package/dist/server.js +83 -1
- package/examples/workshop/.env.example +18 -0
- package/examples/workshop/README.md +13 -0
- package/examples/workshop/app.js +9 -0
- package/examples/workshop/index.html +6 -0
- package/examples/workshop/package.json +8 -0
- package/examples/workshop/schema.sql +10 -0
- package/examples/workshop/server.mjs +88 -0
- package/migrations/001-application-store.sql +7 -0
- package/package.json +28 -7
package/INTEGRATION.md
ADDED
|
@@ -0,0 +1,176 @@
|
|
|
1
|
+
# Integrazione server Connect SDK 0.10.0
|
|
2
|
+
|
|
3
|
+
Nuova esportazione `@eulab/connect/application`, indipendente da Nest/Angular. `ConnectServer`, `ConnectBrowser`, `ConnectOnboardingSource` e le API `/v1/team` della 0.9.0 restano disponibili. Il nuovo modulo compone questi servizi e OIDC; nessuna dipendenza da Prisma, ALORA, profili aziendali o browser storage. Node >=22, dipendenza runtime `jose`; per lo store pronto installare `pg`.
|
|
4
|
+
|
|
5
|
+
## Installazione e prerequisiti
|
|
6
|
+
|
|
7
|
+
```sh
|
|
8
|
+
npm install /percorso/eulab-connect-0.10.0.tgz pg
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
Per presentare la prima pratica **non servono applicazione, sorgente approvata, licenza o client OIDC**. Un amministratore Connect emette una credenziale tecnica da **Attivazioni e migrazioni**, oppure `POST /v1/onboarding/presenters`: nome, deploymentIdentity stabile, scadenza; origini/app verificate sono attestazioni amministrative opzionali. Consegnare ID e segreto una sola volta al backend consumer mediante il proprio secret manager. Non usare credenziali Admin EULAB nel consumer.
|
|
12
|
+
|
|
13
|
+
La prima discovery/invio autenticata riserva `sourceId` al deployment e registra soltanto la provenienza non approvata. Non crea app, aziende, installazioni, identità, licenze o sessioni. Un altro presenter non può assumere un sourceId riservato; ruotare il segreto dello stesso presenter conserva il vincolo. Revoca/scadenza bloccano anche il recupero della configurazione.
|
|
14
|
+
|
|
15
|
+
Sul server Connect applicare le migrazioni fino a **013-onboarding-presenters.sql** tramite il normale comando amministrativo `npm run db:migrate`, dopo revisione/backup. Non applicarle nel database consumer. La candidata non esegue questo aggiornamento operativo automaticamente.
|
|
16
|
+
|
|
17
|
+
Nel consumer preparare PostgreSQL condiviso, chiave AES-256 casuale di 64 cifre esadecimali e namespace stabile distinto per sorgente/app/ambiente. Eseguire `store.migrate()` o `migrations/001-application-store.sql` nel database consumer. Conservare chiave e credenziali solo sul backend.
|
|
18
|
+
|
|
19
|
+
Il percorso precedente resta compatibile: `POST /v1/connect-sources` registra una sorgente con segreto backend; issuer/clientId/redirectUri possono essere forniti staticamente. Le sorgenti esistenti restano approvate per compatibilità: nessuna conversione automatica in presenter.
|
|
20
|
+
|
|
21
|
+
HTTP è rifiutato salvo `allowLoopbackHttp: true` e host `localhost`, `127.0.0.1` o `[::1]`. Configurare HTTPS in ambienti condivisi. Non usare il bypass HTTP per domini privati o reti Docker. URL senza password, frammenti o credenziali. Usare issuer canonico senza slash finale.
|
|
22
|
+
|
|
23
|
+
## Una sola istanza
|
|
24
|
+
|
|
25
|
+
```ts
|
|
26
|
+
import {ConnectApplication, PostgresConnectApplicationStore} from '@eulab/connect/application';
|
|
27
|
+
import {defineFunctions} from '@eulab/connect/server';
|
|
28
|
+
import pg from 'pg';
|
|
29
|
+
|
|
30
|
+
const pool = new pg.Pool({connectionString: process.env.DATABASE_URL});
|
|
31
|
+
const store = new PostgresConnectApplicationStore(pool, 'my-app:development:source-1');
|
|
32
|
+
const connect = new ConnectApplication({
|
|
33
|
+
apiUrl, sourceId, appId, sourceSecret,
|
|
34
|
+
issuer, clientId, clientSecret, redirectUri, appOrigin,
|
|
35
|
+
encryptionKey, store,
|
|
36
|
+
catalog: defineFunctions({appId, version: 1, functions}),
|
|
37
|
+
accounts: {verifyLegacy, provision, restrict},
|
|
38
|
+
});
|
|
39
|
+
```
|
|
40
|
+
|
|
41
|
+
Per partire prima dell’integrazione, usare lo stesso costruttore senza `sourceSecret`, `issuer`, `clientId`, `clientSecret` e `redirectUri`, aggiungendo:
|
|
42
|
+
|
|
43
|
+
```ts
|
|
44
|
+
presenter: {
|
|
45
|
+
id: process.env.CONNECT_PRESENTER_ID,
|
|
46
|
+
secret: process.env.CONNECT_PRESENTER_SECRET,
|
|
47
|
+
deployment: {
|
|
48
|
+
name: 'Workshop sviluppo', environment: 'development',
|
|
49
|
+
origins: [appOrigin], catalogUrl: appOrigin + '/.well-known/eulab-connect.json',
|
|
50
|
+
oidcCallbacks: [appOrigin + '/callback'],
|
|
51
|
+
},
|
|
52
|
+
},
|
|
53
|
+
```
|
|
54
|
+
|
|
55
|
+
I metadati dichiarati non provano proprietà di app, email o URL. L’app verificata univoca può preselezionare il piano, senza concedere accesso. L’amministratore seleziona/crea app, cliente e installazione nella stessa pratica, assegna licenza/ruoli e collega esplicitamente eventuali identità esistenti, poi usa **Esegui migrazione**. Per nuovi presenter `prepare` verifica il piano senza creare oggetti. Password e permessi locali non diventano concessioni automatiche.
|
|
56
|
+
|
|
57
|
+
Prima di completare il piano, registrare nel provider il client Authorization Code/PKCE S256, callback esatta e audience `connect-api`; non abilitare password grant nel consumer. L’amministratore salva issuer/clientId/redirectUri ed eventuale segreto confidential nel piano, separatamente cifrato. Il segreto non torna nel JSON del piano o nell’audit. La configurazione diventa disponibile solo dopo completamento.
|
|
58
|
+
|
|
59
|
+
Il backend esegue `await connect.configuration.sync()` tramite un job o handler POST con Origin verificato; la risposta pubblicabile contiene solo stato e appId. `POST /v1/app-onboarding/configuration` richiede il medesimo presenter e segreto, non il solo deploymentId. La facciata valida origine callback, cifra la configurazione nello store condiviso e la ricarica al riavvio. Non richiamare il metodo basso livello dal browser: la risposta server include segreti. Non sincronizza automaticamente altri processi già avviati: richiamare sync anche su quelle istanze dopo una modifica amministrativa.
|
|
60
|
+
|
|
61
|
+
Prima del completamento sync può restituire `plannedAppId`, utile **solo** per pubblicare `connect.catalog` con l’app selezionata se diversa da quella dichiarata. Richiamare sync all’avvio del backend e dopo un cambio piano; questo suggerimento non è persistito né abilita SSO. Servire il catalogo dalla proprietà `connect.catalog`, non ricostruire il protocollo. Pubblicare un catalogo HTTPS raggiungibile dal server Connect prima dell’esecuzione reale.
|
|
62
|
+
|
|
63
|
+
Le variabili sono lette dalla configurazione backend, mai da un bundle frontend. Lo store è obbligatorio; non esiste un default in memoria. Conservare chiave e namespace identici fra istanze della stessa applicazione. La rotazione della chiave invalida i flussi/sessioni precedenti: pianificare una nuova autenticazione; non è presente un keyring automatico.
|
|
64
|
+
|
|
65
|
+
## Adattatori dell’applicazione
|
|
66
|
+
|
|
67
|
+
- `verifyLegacy({email,password}) → LegacyAccount | null`: verifica locale della password, restituisce ID azienda/persona, nome, ruolo e permessi proposti. Nessun hash o segreto nel risultato. Ambiguità fra aziende deve essere rifiutata o risolta nel proprio contesto locale, mai indovinata. Non crea sessioni.
|
|
68
|
+
- `provision(context,{operationId,transaction}) → {localTenantId,localUserId}`: eseguito **solo dopo** ID token firmato, issuer/audience/nonce/subject, accesso Connect e collegamenti verificati. Risolve gli ID espliciti autorizzati, preserva password/hash/profili esistenti, rifiuta conflitti. Non cercare un account da collegare tramite email. Per utenti Connect-only creare il profilo operativo senza copiare alcuna password Connect nel database locale.
|
|
69
|
+
- `restrict(profile,functionKey,resource) → boolean`: applica isolamento aziendale e restrizioni personali. L’autorizzazione Connect non filtra il database applicativo. Ogni query deve avere anche il proprio predicato sull’azienda autorizzata.
|
|
70
|
+
- `ConnectApplicationStore`: persistenza secondo il contratto TypeScript; usare l’adattatore PostgreSQL pronto se non occorre uno store custom. Catalogo funzioni dichiarato una sola volta nella configurazione.
|
|
71
|
+
|
|
72
|
+
I ruoli locali del contratto sorgente restano quelli pubblici 0.9.0 (`owner`, `manager`, `reception`, `collaborator`); non si sostituisce il modello autorizzativo locale con ruoli inventati dal consumer.
|
|
73
|
+
|
|
74
|
+
## Handler BFF
|
|
75
|
+
|
|
76
|
+
Ogni handler costruisce `BrowserContext = {origin,cookies}`. Per POST verificare l’**Origin reale** della richiesta contro `appOrigin`, prima della chiamata SDK. Non riempire `origin` con un valore fisso che aggiri il controllo. Per callback GET usare l’origine della URL effettiva dopo verifica di Host/proxy fidato: state e cookie proteggono il ritorno OIDC. Non fidarsi di Forwarded/Host arbitrari.
|
|
77
|
+
|
|
78
|
+
Applicare tutte le `CookieDirective` restituite come Set-Cookie: HttpOnly, SameSite=Lax, Secure con HTTPS, Path=/, Max-Age. I cookie HTTPS usano prefisso `__Host-`; non impostare Domain. Non pubblicare `cookies` come JSON sostitutivo dei veri header.
|
|
79
|
+
|
|
80
|
+
| Handler | Metodo SDK | Risultato UI |
|
|
81
|
+
|---|---|---|
|
|
82
|
+
| POST login | `auth.signIn({email,password?},ctx)` | `redirect`, `migration_required`, `pending`, `administrative_required` o `configuration_required` |
|
|
83
|
+
| POST sincronizza configurazione | `configuration.sync()` | `pending`, `configuration_required` o `ready` (solo metadati sicuri) |
|
|
84
|
+
| POST consenso | `migration.submit({challenge,legacyPassword,consentVersion,idempotencyKey,newConnectPassword?},ctx)` | stato/azione della richiesta |
|
|
85
|
+
| POST attivazione | `activation.submit({kind:'activation',companyName,applicant,initialPassword,consentVersion,idempotencyKey},ctx)` | stato/azione; nessuna sessione |
|
|
86
|
+
| GET callback | `auth.callback({state,code,error,iss},ctx)` | handoff opaco, cookie e redirect interno fisso |
|
|
87
|
+
| POST handoff | `auth.exchange(handoff,ctx)` | sessione locale e cookie; nessun token provider |
|
|
88
|
+
| Richiesta autenticata | `auth.resolve(auth.fromCookies(ctx))` | profilo verificato, subject, scadenza |
|
|
89
|
+
| POST refresh | `auth.refresh(sessionId)` | sessione; mai replay della mutazione applicativa |
|
|
90
|
+
| POST logout | `auth.logout(sessionId,ctx)` | `revoked`, `providerRevoked`, cookie eliminato |
|
|
91
|
+
| Operazione sui dati | `access.authorize(sessionId,functionKey,resource)` | autorizzazione centrale + restrizione locale |
|
|
92
|
+
|
|
93
|
+
`sessionId` è il solo handle casuale locale; il BFF può ometterlo dal JSON e conservarlo esclusivamente nel cookie HttpOnly. Non esporre mai `source.loginContext()` o un `ConnectServer` direttamente al browser: sono API backend che includono contesto/credenziali d’installazione. Anche `services()` è una callback **server**.
|
|
94
|
+
|
|
95
|
+
Usare un redirect interno fisso dopo callback. Se il BFF consegna l’handoff alla UI, usare un fragment, `Referrer-Policy: no-referrer`, niente log di URL/credenziali, rimuovere subito il fragment e inviarlo a `auth.exchange`. Non aggiungere un `returnTo` arbitrario. Il demo include tutti gli handler e una UI minima che rende gli esiti discriminati.
|
|
96
|
+
|
|
97
|
+
## Discovery, migrazione e stati
|
|
98
|
+
|
|
99
|
+
`signIn` invoca prima la sorgente Connect. Un collegamento autorizzato conduce direttamente a SSO; la password legacy non viene verificata. Un errore di sorgente o una revoca blocca il flusso, senza fallback legacy operativo.
|
|
100
|
+
|
|
101
|
+
Un conflitto di provenienza restituisce `administrative_required`; un accesso approvato senza configurazione OIDC restituisce `configuration_required`. Non verificano legacy né creano challenge/sessioni. Una pratica pendente restituisce attesa senza provisioning. Se serve una migrazione/reinvio/nuova password, una prova legacy valida crea un challenge opaco di 120 secondi legato al cookie. `migration.submit` richiede consenso versione `2026-10-21-mandatory-v1`, consuma il challenge una volta e ripete la verifica legacy. Non conserva la password legacy nello store. Un errore dopo il consumo richiede una nuova prova/challenge; non ripetere automaticamente.
|
|
102
|
+
|
|
103
|
+
Gli endpoint sorgente aggiungono `nextAction` a `{requestId,state}`. Il campo è opzionale nei tipi SDK per interoperabilità con server 0.9; in assenza di azione esplicita, i fallimenti richiedono assistenza (nessuna deduzione da messaggi HTTP).
|
|
104
|
+
|
|
105
|
+
| `nextAction` | UI e comportamento |
|
|
106
|
+
|---|---|
|
|
107
|
+
| `wait` | Attesa; aggiornamento tramite nuova discovery esplicita |
|
|
108
|
+
| `sign_in` | Nuovo login SSO |
|
|
109
|
+
| `choose_connect_password` | Solo migrazione legacy recuperabile: nuova prova locale + consenso + password Connect diversa |
|
|
110
|
+
| `resubmit` | Nuova prova e consenso, invio esplicito secondo i vincoli server |
|
|
111
|
+
| `contact_admin` | Attivazione con password rifiutata, collegamento esplicito o verifica amministrativa; nessuna prova legacy né merge per email |
|
|
112
|
+
| `closed` | Richiesta/pratica chiusa; nessuna riapertura tramite recupero |
|
|
113
|
+
|
|
114
|
+
Compatibilità: il server conserva il reinvio già supportato di una richiesta personale scaduta, **solo se la pratica aziendale è ancora riutilizzabile**. Le pratiche aziendali `rejected`, `expired`, `completed` e quelle `migrating` non vengono riaperte dal recupero. Una richiesta completata resta completata.
|
|
115
|
+
|
|
116
|
+
## Recupero password rifiutata
|
|
117
|
+
|
|
118
|
+
Una policy provider può produrre `failed` / `password_change_required` dopo la cancellazione della credenziale transitoria. La discovery restituisce `choose_connect_password` soltanto per una migrazione legacy recuperabile, senza subject o collegamento amministrativo, in una pratica ancora aperta. Una nuova attivazione restituisce `contact_admin`: il contratto attuale non offre un recupero pubblico senza prova legacy. Anche richieste già collegate richiedono assistenza; una pratica in esecuzione restituisce `wait`, una pratica terminale non propone recupero. Discovery, replay e recupero usano gli stessi criteri server. Con `contact_admin`, `auth.signIn` restituisce `pending` senza invocare `verifyLegacy`, creare challenge o rilasciare sessioni.
|
|
119
|
+
|
|
120
|
+
La UI chiede due campi distinti: password locale per la prova, nuova password per Connect. La facciata confronta le due, rifiuta valori uguali, verifica di nuovo il legacy e invia **solo la nuova credenziale** a `POST /v1/app-onboarding/password-recovery`. La password locale non viene inviata in questo recupero. Il consenso è legato al challenge monouso verificato.
|
|
121
|
+
|
|
122
|
+
Il contratto backend di recupero richiede schemaVersion, appId/sourceId, requestId, localTenantId, localUserId, email, consentVersion e newPassword. Il bearer della sorgente autentica il backend che **attesta** prova legacy fresca, consenso e distinzione delle password: Connect non può verificare la password del database locale. Se si usa il metodo basso livello `ConnectOnboardingSource.recoverPassword`, il chiamante deve attuare questi controlli; per la prossima app utilizzare `ConnectApplication.migration.submit`.
|
|
123
|
+
|
|
124
|
+
Il server blocca la pratica con lo stesso lock usato da esecuzione/rifiuto, verifica sorgente/app/ID locali, richiede stato failed + password_change_required, assenza di subject/collegamento esplicito e una **nuova chiave idempotente**. Cifra la nuova password con AAD requestId e TTL esistenti, imposta pending, non crea identità né esegue la migrazione automaticamente. L’amministratore deve eseguire la pratica. La chiave di recupero resta riservata: lo stesso invio restituisce lo stato corrente e non sostituisce la credenziale; una nuova credenziale dopo un altro rifiuto richiede un’altra chiave e una nuova prova/consenso. Non cambia hash legacy o password di identità esistenti.
|
|
125
|
+
|
|
126
|
+
## Atomicità e concorrenza
|
|
127
|
+
|
|
128
|
+
Store PostgreSQL: transazioni READ COMMITTED, lock advisory **di sessione** su namespace + chiave del flusso/sessione. Occorre un Pool con connessioni dedicate fino al rilascio; non usare PgBouncer in transaction pooling. I lock sono rilasciati anche su rollback; una connessione persa rilascia il lock nel server PostgreSQL. Timeout lock 15 secondi; chiamate OIDC/sorgente con timeout 10 secondi. Dimensionare il pool in base alla concorrenza; gli handler non devono mantenere altre transazioni locali in attesa dello stesso flusso.
|
|
129
|
+
|
|
130
|
+
- State, nonce, PKCE e contesto sono cifrati AES-256-GCM con AAD source/app/record; cookie contiene solo un valore casuale correlato.
|
|
131
|
+
- Callback: consumo state **prima** del grant, in transazione già confermata. Un crash impedisce il replay ma richiede nuovo login. TTL 10 minuti. ID token verificato con JWKS, issuer, audience, azp, nonce e subject; accesso e mapping locali verificati nuovamente.
|
|
132
|
+
- Handoff: TTL 60 secondi; cookie correlato, lock esclusivo, verifica accesso, provisioning e consumo nella stessa transazione. Se il provisioning usa `transaction.sql` sullo stesso database, i suoi cambiamenti e il consumo sono atomici. Non chiamare `checkpoint()` nell’adattatore account.
|
|
133
|
+
- Database diverso: nessuna promessa di transazione distribuita. Usare `operationId` come chiave idempotente persistente nel sistema locale e riconciliare una chiamata ripetuta dopo rollback/crash; restituire sempre gli stessi ID autorizzati. Il flusso può richiamare provision più volte, ma deve produrre un solo profilo.
|
|
134
|
+
- Sessioni: scadenza assoluta (8 ore di default, configurabile 60–604800 secondi), refresh preventivo sotto 30 secondi. Ogni resolve/azione riverifica sorgente e `/v1/access`, includendo subject, app, installazione e ID locale. Nessuna fiducia in una licenza memorizzata nel cookie.
|
|
135
|
+
- Refresh: lock per sessione fra processi. Un timestamp condiviso deduplica refresh forzati per 5 secondi. Prima del grant viene scritto un intento cifrato e chiamato `checkpoint()` (commit che **mantiene il lock di sessione**). Una nuova generazione diventa valida solo al commit del nuovo token. Timeout, risposta ambigua o crash conservano l’intento e rendono inutilizzabile la vecchia sessione; nuovo SSO richiesto, mai replay del vecchio refresh token. Gli intenti scadono con la sessione e vengono rimossi dal pruning.
|
|
136
|
+
- Logout: revoca locale durevole sotto lo stesso lock, prima del logout provider. `providerRevoked:false` segnala il fallimento remoto; `null` segnala nessuna credenziale disponibile e nessun tentativo remoto; la sessione locale resta revocata. Dopo una revoca rilevata da resolve la sessione provider può restare attiva nel provider fino a scadenza/logout globale; non si certifica revoca globale senza conferma.
|
|
137
|
+
- Nessuna chiamata applicativa viene ritentata automaticamente dopo rinnovo o risposta incerta.
|
|
138
|
+
|
|
139
|
+
Eseguire `store.prune()` periodicamente per eliminare ciphertext scaduti. Scadenza e consumo vengono comunque verificati a ogni lettura; il pruning non è una condizione per la sicurezza. Non registrare request body, cookie, state/code, token o ciphertext in audit applicativi.
|
|
140
|
+
|
|
141
|
+
## Servizi esistenti e diagnostica
|
|
142
|
+
|
|
143
|
+
```ts
|
|
144
|
+
await connect.services(sessionId, (server, token) => server.teamOverview(token));
|
|
145
|
+
await connect.services(sessionId, (server, token) => server.whatsapp(token).outbox());
|
|
146
|
+
await connect.services(sessionId, server => server.registerFunctions(catalogUrl));
|
|
147
|
+
const report = await connect.diagnose(emailFacoltativa);
|
|
148
|
+
```
|
|
149
|
+
|
|
150
|
+
`services` condivide contesto e sessione autenticati; non consegnare la callback o il token al frontend. Configurare l’URL del catalogo esplicitamente per `registerFunctions(catalogUrl)`.
|
|
151
|
+
|
|
152
|
+
`ConnectApplicationError.code` è un’unione sicura: invalid_configuration, invalid_credentials, invalid_context, invalid_flow, invalid_consent, invalid_password, access_denied, session_expired, provider_unavailable, provision_conflict. Il BFF deve rendere soltanto code tipizzati; per le API basso livello restano gli errori compatibili precedenti. Non esporre errori database/provider grezzi.
|
|
153
|
+
|
|
154
|
+
`diagnose` è read-only: verifica configurazione già validata dal costruttore, discovery issuer e autenticazione sorgente. `authorization` resta `not_checked`: né discovery, né email, né raggiungibilità certificano un token utente, client OIDC autorizzato, licenza o associazione applicativa. Il costruttore segnala la configurazione non valida con `invalid_configuration`; `ConnectApplication.diagnose(config)` permette alla CLI di ottenere un report tipizzato anche prima della costruzione valida. Nessun segreto nei risultati. Per ALORA la configurazione richiesta è descritta in `docs/SDK-ALORA-DEVELOPMENT.md` del repository Connect; Il riferimento iniziale era ALORA in sola lettura; per l’adozione consumer successiva vedere la sezione finale di questa guida.
|
|
155
|
+
|
|
156
|
+
## Esempio e verifica
|
|
157
|
+
|
|
158
|
+
`examples/workshop` è un’app eseguibile con pagine HTML, BFF Node, account/project store SQL, migrazioni, diagnostica e seed legacy esplicito. Copiarla e installare il tarball; non copia alcun protocollo. I test `connect-application.test.ts` coprono provider simulato e possono usare PostgreSQL reale con `CONNECT_SDK_TEST_DATABASE_URL`. `node scripts/check-sdk-real-provider.mjs` crea e rimuove PostgreSQL e Keycloak temporanei: recupero password reale, SSO/PKCE/ID token, refresh e revoche; Connect usa il proprio harness PGlite e amministrazione simulata. Il report distingue esattamente questi livelli. Browser grafico, proxy/TLS pubblico e produzione richiedono collaudi separati.
|
|
159
|
+
|
|
160
|
+
|
|
161
|
+
## Riutilizzo nelle app e stato del consumer ALORA
|
|
162
|
+
|
|
163
|
+
Il consumer ALORA ha adottato presenter e configuration.sync della candidata schema 013, eliminando il proprio percorso enrollment separato. La configurazione tecnica è predisposta; il collaudo utente finale non è stato eseguito automaticamente. Non confondere l’emissione del presenter con l’approvazione di un’integrazione.
|
|
164
|
+
|
|
165
|
+
Una nuova app riusa lo stesso modulo, store e metodi; implementa soltanto adattatori di dominio e HTTP. Eventuali token/sessioni legacy dell’app restano un adattatore di compatibilità, non un secondo protocollo da propagare. Lo SDK attuale assume endpoint provider Keycloak, appOrigin/callback nella stessa origine e quattro ruoli locali interoperabili (owner/manager/reception/collaborator). Altri modelli devono essere adattati esplicitamente senza ampliare permessi, o richiedono un’evoluzione coordinata del contratto. Questo limite non riguarda i ruoli Connect configurabili e le permission key applicative.
|
|
166
|
+
|
|
167
|
+
La facciata non risolve da sola DNS/TLS del deployment: issuer canonico, URL catalogo ammesso e raggiungibilità da browser/backend/Connect devono essere configurati nell’ambiente reale. Il client OIDC dedicato resta una responsabilità amministrativa. Non usare localhost nel container presumendo che indichi l’host.
|
|
168
|
+
|
|
169
|
+
|
|
170
|
+
## Origine di trasporto backend del provider
|
|
171
|
+
|
|
172
|
+
`oidcTransportOrigin` opzionale configura esclusivamente l’origine delle chiamate server discovery/token/JWKS/logout, preservando il percorso del realm. È un parametro server amministrativo, non ricevuto dal browser. Sono ammessi solo HTTPS o HTTP loopback con opt-in esplicito; path diversi da `/`, query, fragment e credenziali sono rifiutati.
|
|
173
|
+
|
|
174
|
+
L’issuer canonico resta quello approvato: URL di autorizzazione nel browser, confronto `iss`, audience, nonce e PKCE non vengono riscritti né disattivati. Un esempio Docker locale è issuer `http://localhost:8080/realms/eulab` e origine di trasporto `https://nginx`, con CA attendibile e relay privato verso il medesimo Keycloak. Non usare il parametro per collegare un provider diverso dall’issuer approvato.
|
|
175
|
+
|
|
176
|
+
Correzione del 24 ottobre adottata per il problema di raggiungibilità rilevato in ALORA dopo la migrazione. Compilazione/pacchetto aggiornati; il login end-to-end viene riprovato dall’utente, non è dichiarato collaudato da questa modifica.
|
package/README.md
CHANGED
|
@@ -1,3 +1,9 @@
|
|
|
1
|
+
## Facciata applicativa 0.10.0
|
|
2
|
+
|
|
3
|
+
`@eulab/connect/application` esporta `ConnectApplication` e lo store PostgreSQL condiviso. Una sola istanza governa discovery, migrazione/attivazione, recupero password, OIDC/PKCE, cookie/handoff, sessioni cifrate e rinnovi concorrenti. I metodi 0.9.0 restano compatibili.
|
|
4
|
+
|
|
5
|
+
Guida completa: [INTEGRATION.md](./INTEGRATION.md). Applicazione BFF indipendente pronta da eseguire: [Workshop](./examples/workshop/README.md). Migrazione store: `migrations/001-application-store.sql`. Il server Connect deve avere schema 013 per le credenziali tecniche prima dell’integrazione (012 per il recupero password). Una sola facciata permette richiesta senza sorgente approvata o client OIDC, attesa senza sessione e sincronizzazione cifrata della configurazione dopo approvazione. Nessuna pubblicazione automatica.
|
|
6
|
+
|
|
1
7
|
# EULab Connect SDK
|
|
2
8
|
|
|
3
9
|
SDK ESM per SSO, permessi, utenti e WhatsApp tramite EULab Connect. Richiede un'installazione Connect configurata; il server SDK richiede Node.js 22 o successivo.
|
|
@@ -26,4 +32,32 @@ L'entrypoint server espone `ConnectServer` e `verifyWebhook`:
|
|
|
26
32
|
import {ConnectServer, verifyWebhook} from '@eulab/connect/server';
|
|
27
33
|
```
|
|
28
34
|
|
|
29
|
-
Gli export browser e server includono le dichiarazioni TypeScript. Il pacchetto contiene solo JavaScript compilato, tipi e questo README; non contiene credenziali o profili WhatsApp. I segreti dell
|
|
35
|
+
Gli export browser e server includono le dichiarazioni TypeScript. Il pacchetto contiene solo JavaScript compilato, tipi e questo README; non contiene credenziali o profili WhatsApp. I segreti dell’installazione devono rimanere sul backend. Il backend deve verificare licenza e permessi per ogni operazione.
|
|
36
|
+
|
|
37
|
+
`ConnectServer.mirrorUser()` collega un utente locale a Connect. Il campo opzionale `initialPassword` proviene da una verifica locale appena conclusa, serve solo a inizializzare una nuova identità nel provider e non viene conservato da Connect. Non è disponibile nell’SDK browser.
|
|
38
|
+
|
|
39
|
+
`ConnectOnboardingSource` (server, dalla versione 0.9.0) è il client backend del contratto di attivazione assistita. Richiede la credenziale bootstrap della sorgente, registrata da EULAB prima dell’app/installazione, e non deve essere usato nel browser:
|
|
40
|
+
|
|
41
|
+
```ts
|
|
42
|
+
import {ConnectOnboardingSource} from '@eulab/connect/server';
|
|
43
|
+
const onboarding = new ConnectOnboardingSource({
|
|
44
|
+
apiUrl: 'https://auth.eulab.cloud',
|
|
45
|
+
sourceId: 'alora-produzione',
|
|
46
|
+
appId: 'alora',
|
|
47
|
+
secret: process.env.CONNECT_BOOTSTRAP_SECRET!,
|
|
48
|
+
});
|
|
49
|
+
const lookup = await onboarding.loginContext('persona@example.test');
|
|
50
|
+
if (lookup.status === 'not_found') {
|
|
51
|
+
const receipt = await onboarding.submit({
|
|
52
|
+
kind: 'migration',
|
|
53
|
+
consentVersion: '2026-10-21-mandatory-v1',
|
|
54
|
+
localTenant: {id: 'tenant-1', name: 'Azienda', slug: 'azienda'},
|
|
55
|
+
localUser: {id: 'user-1', email: 'persona@example.test', firstName: 'Nome', lastName: 'Cognome', role: 'owner', permissions: []},
|
|
56
|
+
initialPassword: passwordVerifiedLocally,
|
|
57
|
+
}, idempotencyKey);
|
|
58
|
+
}
|
|
59
|
+
```
|
|
60
|
+
|
|
61
|
+
`loginContext` non autentica l’utente e restituisce un contesto solo per collegamenti espliciti autorizzati alla sorgente. `submit` accetta `Idempotency-Key` stabili: la stessa chiave con lo stesso body restituisce la pratica esistente, con un body diverso produce un errore 409 e non sostituisce la credenziale. `ConnectOnboardingError.status` conserva il codice HTTP (401/403/409/...) per la gestione consumer. La password transitoria non viene mai restituita, registrata o inclusa nei tipi di risposta.
|
|
62
|
+
|
|
63
|
+
Le API `/v1/team` sono esposte da `teamOverview`, `teamUsers`, `teamRoles`, `teamFunctions`, `createTeamRole`, `updateTeamRole`, `deleteTeamRole`, `setTeamUserRoles`, `revokeTeamUser` e `restoreTeamUser`. Cliente e applicazione derivano dall’installazione autenticata; ogni assegnazione resta limitata a funzioni attive, licenziate e presenti nella delega del chiamante. Le operazioni di modifica richiedono `team.manage` nella delega effettiva.
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
/** Minimal pg-compatible driver. Pass a Pool, never a single shared Client. */
|
|
2
|
+
export interface ConnectSqlClient {
|
|
3
|
+
query(sql: string, values?: any[]): Promise<{
|
|
4
|
+
rows: any[];
|
|
5
|
+
}>;
|
|
6
|
+
release(): void;
|
|
7
|
+
}
|
|
8
|
+
export interface ConnectSqlPool {
|
|
9
|
+
connect(): Promise<ConnectSqlClient>;
|
|
10
|
+
}
|
|
11
|
+
export interface ConnectStoreTransaction {
|
|
12
|
+
get(id: string): Promise<string | null>;
|
|
13
|
+
put(id: string, cipher: string, expiresAt: number): Promise<void>;
|
|
14
|
+
remove(id: string): Promise<void>;
|
|
15
|
+
/** Available for provisioning in the same database transaction. */
|
|
16
|
+
readonly sql?: ConnectSqlClient;
|
|
17
|
+
/** Commit a fail-closed refresh intent while retaining the exclusive lock. */
|
|
18
|
+
checkpoint(): Promise<void>;
|
|
19
|
+
}
|
|
20
|
+
export interface ConnectApplicationStore {
|
|
21
|
+
/** Exclusive cross-process lock, with commit/rollback of all writes in fn. */
|
|
22
|
+
transaction<T>(key: string, fn: (tx: ConnectStoreTransaction) => Promise<T>): Promise<T>;
|
|
23
|
+
}
|
|
24
|
+
export declare const connectApplicationStoreMigration = "\nCREATE TABLE IF NOT EXISTS connect_sdk_schema(version integer PRIMARY KEY);\nCREATE TABLE IF NOT EXISTS connect_sdk_records(\n namespace text NOT NULL, id text NOT NULL, cipher text NOT NULL,\n expires_at timestamptz NOT NULL, PRIMARY KEY(namespace,id));\nCREATE INDEX IF NOT EXISTS connect_sdk_expiry ON connect_sdk_records(expires_at);\nINSERT INTO connect_sdk_schema(version) VALUES(1) ON CONFLICT DO NOTHING;\n";
|
|
25
|
+
/** Records are encrypted by ConnectApplication; the store never sees provider tokens. */
|
|
26
|
+
export declare class PostgresConnectApplicationStore implements ConnectApplicationStore {
|
|
27
|
+
private readonly pool;
|
|
28
|
+
private readonly namespace;
|
|
29
|
+
constructor(pool: ConnectSqlPool, namespace: string);
|
|
30
|
+
migrate(): Promise<void>;
|
|
31
|
+
prune(): Promise<void>;
|
|
32
|
+
transaction<T>(key: string, fn: (tx: ConnectStoreTransaction) => Promise<T>): Promise<T>;
|
|
33
|
+
}
|
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
export const connectApplicationStoreMigration = `
|
|
2
|
+
CREATE TABLE IF NOT EXISTS connect_sdk_schema(version integer PRIMARY KEY);
|
|
3
|
+
CREATE TABLE IF NOT EXISTS connect_sdk_records(
|
|
4
|
+
namespace text NOT NULL, id text NOT NULL, cipher text NOT NULL,
|
|
5
|
+
expires_at timestamptz NOT NULL, PRIMARY KEY(namespace,id));
|
|
6
|
+
CREATE INDEX IF NOT EXISTS connect_sdk_expiry ON connect_sdk_records(expires_at);
|
|
7
|
+
INSERT INTO connect_sdk_schema(version) VALUES(1) ON CONFLICT DO NOTHING;
|
|
8
|
+
`;
|
|
9
|
+
/** Records are encrypted by ConnectApplication; the store never sees provider tokens. */
|
|
10
|
+
export class PostgresConnectApplicationStore {
|
|
11
|
+
pool;
|
|
12
|
+
namespace;
|
|
13
|
+
constructor(pool, namespace) {
|
|
14
|
+
this.pool = pool;
|
|
15
|
+
this.namespace = namespace;
|
|
16
|
+
if (!namespace || namespace.length > 200)
|
|
17
|
+
throw new Error('Invalid Connect store namespace');
|
|
18
|
+
}
|
|
19
|
+
async migrate() { const client = await this.pool.connect(); try {
|
|
20
|
+
await client.query('BEGIN');
|
|
21
|
+
await client.query('SELECT pg_advisory_xact_lock(901272)');
|
|
22
|
+
await client.query(connectApplicationStoreMigration);
|
|
23
|
+
await client.query('COMMIT');
|
|
24
|
+
}
|
|
25
|
+
catch (e) {
|
|
26
|
+
await client.query('ROLLBACK');
|
|
27
|
+
throw e;
|
|
28
|
+
}
|
|
29
|
+
finally {
|
|
30
|
+
client.release();
|
|
31
|
+
} }
|
|
32
|
+
async prune() { const client = await this.pool.connect(); try {
|
|
33
|
+
await client.query('DELETE FROM connect_sdk_records WHERE namespace=$1 AND expires_at<=now()', [this.namespace]);
|
|
34
|
+
}
|
|
35
|
+
finally {
|
|
36
|
+
client.release();
|
|
37
|
+
} }
|
|
38
|
+
async transaction(key, fn) {
|
|
39
|
+
const client = await this.pool.connect();
|
|
40
|
+
try {
|
|
41
|
+
await client.query("SET lock_timeout='15s'");
|
|
42
|
+
await client.query('SELECT pg_advisory_lock(hashtextextended($1,0))', [JSON.stringify([this.namespace, key])]);
|
|
43
|
+
await client.query('BEGIN');
|
|
44
|
+
const tx = { sql: client,
|
|
45
|
+
checkpoint: async () => { await client.query('COMMIT'); await client.query('BEGIN'); },
|
|
46
|
+
get: async (id) => (await client.query('SELECT cipher FROM connect_sdk_records WHERE namespace=$1 AND id=$2 AND expires_at>now()', [this.namespace, id])).rows[0]?.cipher ?? null,
|
|
47
|
+
put: async (id, cipher, expiry) => { await client.query('INSERT INTO connect_sdk_records(namespace,id,cipher,expires_at) VALUES($1,$2,$3,$4) ON CONFLICT(namespace,id) DO UPDATE SET cipher=EXCLUDED.cipher,expires_at=EXCLUDED.expires_at', [this.namespace, id, cipher, new Date(expiry)]); },
|
|
48
|
+
remove: async (id) => { await client.query('DELETE FROM connect_sdk_records WHERE namespace=$1 AND id=$2', [this.namespace, id]); }
|
|
49
|
+
};
|
|
50
|
+
const result = await fn(tx);
|
|
51
|
+
await client.query('COMMIT');
|
|
52
|
+
return result;
|
|
53
|
+
}
|
|
54
|
+
catch (e) {
|
|
55
|
+
await client.query('ROLLBACK');
|
|
56
|
+
throw e;
|
|
57
|
+
}
|
|
58
|
+
finally {
|
|
59
|
+
try {
|
|
60
|
+
await client.query('SELECT pg_advisory_unlock(hashtextextended($1,0))', [JSON.stringify([this.namespace, key])]);
|
|
61
|
+
await client.query('RESET lock_timeout');
|
|
62
|
+
}
|
|
63
|
+
finally {
|
|
64
|
+
client.release();
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
}
|
|
68
|
+
}
|
|
@@ -0,0 +1,212 @@
|
|
|
1
|
+
import { ConnectOnboardingSource, ConnectServer } from './server.js';
|
|
2
|
+
import type { AuthorizedConnectContext, OnboardingRequestStatus, AppOnboardingActivationRequest, OnboardingNextAction, DeploymentMetadata } from './server.js';
|
|
3
|
+
import type { FunctionMatrix } from './functions.js';
|
|
4
|
+
import type { ConnectApplicationStore, ConnectStoreTransaction } from './application-store.js';
|
|
5
|
+
export * from './application-store.js';
|
|
6
|
+
export declare const connectConsentVersion = "2026-10-21-mandatory-v1";
|
|
7
|
+
export type ConnectApplicationErrorCode = 'invalid_configuration' | 'invalid_credentials' | 'invalid_context' | 'invalid_flow' | 'invalid_consent' | 'invalid_password' | 'access_denied' | 'session_expired' | 'provider_unavailable' | 'provision_conflict';
|
|
8
|
+
export type ConnectCallbackStage = 'flow' | 'token_exchange' | 'id_token' | 'context' | 'authorization' | 'handoff';
|
|
9
|
+
export declare class ConnectApplicationError extends Error {
|
|
10
|
+
readonly code: ConnectApplicationErrorCode;
|
|
11
|
+
callbackStage?: ConnectCallbackStage;
|
|
12
|
+
authorizationDetail?: 'http_401' | 'http_403' | 'http_other' | 'transport' | 'login_denied' | 'app_mismatch' | 'installation_mismatch' | 'subject_mismatch' | 'local_user_mismatch';
|
|
13
|
+
constructor(code: ConnectApplicationErrorCode);
|
|
14
|
+
}
|
|
15
|
+
export interface BrowserContext {
|
|
16
|
+
origin: string;
|
|
17
|
+
cookies: Record<string, string | undefined>;
|
|
18
|
+
}
|
|
19
|
+
export interface CookieDirective {
|
|
20
|
+
name: string;
|
|
21
|
+
value: string;
|
|
22
|
+
httpOnly: true;
|
|
23
|
+
secure: boolean;
|
|
24
|
+
sameSite: 'lax';
|
|
25
|
+
path: '/';
|
|
26
|
+
maxAge: number;
|
|
27
|
+
}
|
|
28
|
+
export interface LegacyAccount {
|
|
29
|
+
localTenant: {
|
|
30
|
+
id: string;
|
|
31
|
+
name: string;
|
|
32
|
+
slug: string;
|
|
33
|
+
};
|
|
34
|
+
localUser: Omit<AuthorizedConnectContext['user'], 'subject'>;
|
|
35
|
+
}
|
|
36
|
+
export interface LocalProfile {
|
|
37
|
+
localUserId: string;
|
|
38
|
+
localTenantId: string;
|
|
39
|
+
}
|
|
40
|
+
export interface ConnectAccountAdapter {
|
|
41
|
+
verifyLegacy(input: {
|
|
42
|
+
email: string;
|
|
43
|
+
password: string;
|
|
44
|
+
}): Promise<LegacyAccount | null>;
|
|
45
|
+
/** Must be idempotent on operationId and reject conflicting existing IDs/subjects. Never join by email. */
|
|
46
|
+
provision(context: AuthorizedConnectContext, operation: {
|
|
47
|
+
operationId: string;
|
|
48
|
+
transaction: ConnectStoreTransaction;
|
|
49
|
+
}): Promise<LocalProfile>;
|
|
50
|
+
restrict(profile: LocalProfile, functionKey: string, resource: unknown): Promise<boolean>;
|
|
51
|
+
}
|
|
52
|
+
export interface ConnectApplicationConfig {
|
|
53
|
+
apiUrl: string;
|
|
54
|
+
sourceId: string;
|
|
55
|
+
appId: string;
|
|
56
|
+
sourceSecret?: string;
|
|
57
|
+
presenter?: {
|
|
58
|
+
id: string;
|
|
59
|
+
secret: string;
|
|
60
|
+
deployment: DeploymentMetadata;
|
|
61
|
+
};
|
|
62
|
+
issuer?: string;
|
|
63
|
+
clientId?: string;
|
|
64
|
+
clientSecret?: string;
|
|
65
|
+
redirectUri?: string;
|
|
66
|
+
appOrigin: string;
|
|
67
|
+
/** Server-only origin for provider HTTP calls; canonical issuer/token validation and browser redirects stay unchanged. */
|
|
68
|
+
oidcTransportOrigin?: string;
|
|
69
|
+
encryptionKey: string;
|
|
70
|
+
store: ConnectApplicationStore;
|
|
71
|
+
accounts: ConnectAccountAdapter;
|
|
72
|
+
catalog: FunctionMatrix;
|
|
73
|
+
/** Explicit opt-in restricted to loopback HTTP. */ allowLoopbackHttp?: boolean;
|
|
74
|
+
sessionTtlSeconds?: number;
|
|
75
|
+
}
|
|
76
|
+
export type SignInResult = {
|
|
77
|
+
status: 'administrative_required';
|
|
78
|
+
reason: 'source_conflict';
|
|
79
|
+
} | {
|
|
80
|
+
status: 'configuration_required';
|
|
81
|
+
appId: string;
|
|
82
|
+
} | {
|
|
83
|
+
status: 'redirect';
|
|
84
|
+
url: string;
|
|
85
|
+
cookies: CookieDirective[];
|
|
86
|
+
} | {
|
|
87
|
+
status: 'migration_required';
|
|
88
|
+
challenge: string;
|
|
89
|
+
consentVersion: string;
|
|
90
|
+
request?: OnboardingRequestStatus;
|
|
91
|
+
cookies: CookieDirective[];
|
|
92
|
+
} | {
|
|
93
|
+
status: 'pending';
|
|
94
|
+
request: OnboardingRequestStatus;
|
|
95
|
+
nextAction: OnboardingNextAction;
|
|
96
|
+
};
|
|
97
|
+
export interface ConnectDiagnosticReport {
|
|
98
|
+
checks: {
|
|
99
|
+
code: 'configuration' | 'discovery' | 'source' | 'authorization';
|
|
100
|
+
status: 'ok' | 'failed' | 'not_checked';
|
|
101
|
+
}[];
|
|
102
|
+
}
|
|
103
|
+
export interface ApplicationSession {
|
|
104
|
+
sessionId: string;
|
|
105
|
+
profile: LocalProfile;
|
|
106
|
+
subject: string;
|
|
107
|
+
expiresAt: number;
|
|
108
|
+
}
|
|
109
|
+
/** Server-only application facade. No provider token appears in a public result. */
|
|
110
|
+
export declare class ConnectApplication {
|
|
111
|
+
private readonly config;
|
|
112
|
+
/** Read-only entry point usable even when construction would reject invalid configuration. */
|
|
113
|
+
static diagnose(config: ConnectApplicationConfig, email?: string): Promise<ConnectDiagnosticReport>;
|
|
114
|
+
readonly source: ConnectOnboardingSource;
|
|
115
|
+
get catalog(): FunctionMatrix;
|
|
116
|
+
private readonly key;
|
|
117
|
+
private jwks?;
|
|
118
|
+
private settings?;
|
|
119
|
+
private plannedAppId?;
|
|
120
|
+
private readonly prefix;
|
|
121
|
+
private readonly ttl;
|
|
122
|
+
constructor(config: ConnectApplicationConfig);
|
|
123
|
+
private validateConfiguration;
|
|
124
|
+
private loadSettings;
|
|
125
|
+
private oidc;
|
|
126
|
+
readonly configuration: {
|
|
127
|
+
sync: () => Promise<{
|
|
128
|
+
plannedAppId?: string | undefined;
|
|
129
|
+
status: "pending" | "configuration_required";
|
|
130
|
+
appId?: undefined;
|
|
131
|
+
} | {
|
|
132
|
+
status: "ready";
|
|
133
|
+
appId: string;
|
|
134
|
+
}>;
|
|
135
|
+
};
|
|
136
|
+
private transaction;
|
|
137
|
+
private cookie;
|
|
138
|
+
private browser;
|
|
139
|
+
private seal;
|
|
140
|
+
private open;
|
|
141
|
+
private put;
|
|
142
|
+
private read;
|
|
143
|
+
private take;
|
|
144
|
+
private client;
|
|
145
|
+
private onboarding;
|
|
146
|
+
private current;
|
|
147
|
+
private verifyAccess;
|
|
148
|
+
private providerUrl;
|
|
149
|
+
private grant;
|
|
150
|
+
private next;
|
|
151
|
+
private begin;
|
|
152
|
+
readonly auth: {
|
|
153
|
+
signIn: (input: {
|
|
154
|
+
email: string;
|
|
155
|
+
password?: string;
|
|
156
|
+
}, ctx: BrowserContext) => Promise<SignInResult>;
|
|
157
|
+
callback: (input: {
|
|
158
|
+
state: string;
|
|
159
|
+
code?: string;
|
|
160
|
+
error?: string;
|
|
161
|
+
iss?: string;
|
|
162
|
+
}, ctx: BrowserContext) => Promise<{
|
|
163
|
+
status: "handoff";
|
|
164
|
+
handoff: string;
|
|
165
|
+
cookies: CookieDirective[];
|
|
166
|
+
}>;
|
|
167
|
+
exchange: (handoff: string, ctx: BrowserContext) => Promise<{
|
|
168
|
+
status: "authenticated";
|
|
169
|
+
session: {
|
|
170
|
+
sessionId: string;
|
|
171
|
+
profile: LocalProfile;
|
|
172
|
+
subject: string;
|
|
173
|
+
expiresAt: number;
|
|
174
|
+
};
|
|
175
|
+
cookies: CookieDirective[];
|
|
176
|
+
}>;
|
|
177
|
+
resolve: (sessionId: string) => Promise<ApplicationSession>;
|
|
178
|
+
refresh: (sessionId: string) => Promise<ApplicationSession>;
|
|
179
|
+
fromCookies: (ctx: BrowserContext) => string;
|
|
180
|
+
logout: (sessionId: string, ctx: BrowserContext) => Promise<{
|
|
181
|
+
revoked: boolean;
|
|
182
|
+
providerRevoked: boolean | null;
|
|
183
|
+
cookies: CookieDirective[];
|
|
184
|
+
}>;
|
|
185
|
+
};
|
|
186
|
+
private resolve;
|
|
187
|
+
private withSession;
|
|
188
|
+
readonly migration: {
|
|
189
|
+
submit: (input: {
|
|
190
|
+
challenge: string;
|
|
191
|
+
legacyPassword: string;
|
|
192
|
+
consentVersion: string;
|
|
193
|
+
idempotencyKey: string;
|
|
194
|
+
newConnectPassword?: string;
|
|
195
|
+
}, ctx: BrowserContext) => Promise<OnboardingRequestStatus>;
|
|
196
|
+
};
|
|
197
|
+
readonly activation: {
|
|
198
|
+
submit: (input: AppOnboardingActivationRequest & {
|
|
199
|
+
consentVersion: string;
|
|
200
|
+
idempotencyKey: string;
|
|
201
|
+
}, ctx: BrowserContext) => Promise<OnboardingRequestStatus>;
|
|
202
|
+
};
|
|
203
|
+
readonly access: {
|
|
204
|
+
authorize: (sessionId: string, functionKey: string, resource?: unknown) => Promise<{
|
|
205
|
+
allowed: boolean;
|
|
206
|
+
reason: string;
|
|
207
|
+
}>;
|
|
208
|
+
};
|
|
209
|
+
/** All existing Connect services share this authenticated server session. No callback is retried. */
|
|
210
|
+
services<T>(sessionId: string, operation: (client: ConnectServer, accessToken: string) => Promise<T>): Promise<T>;
|
|
211
|
+
diagnose(email?: string): Promise<ConnectDiagnosticReport>;
|
|
212
|
+
}
|