domainkit 0.10.0 → 0.12.0

package/dist/types/Connect.d.ts

@@ -113,6 +113,8 @@ export interface Snapshot {
     readonly connection: Storage.Connection | null;
     readonly authorization: Pick<Storage.Authorization, "id" | "provider" | "method" | "capabilities" | "revocation"> | null;
     readonly lastReceiptId: string | null;
+    /** How many domains this domain's connection serves, including this one; `0` without one. */
+    readonly connectionDomains: number;
     /** Other connections of this owner that could serve this domain. */
     readonly reusable: ReadonlyArray<{
         readonly connection: Storage.Connection;
@@ -410,8 +412,39 @@ export declare const Discovery: {
         }>;
     }, "_tag">;
 };
+/** One zone a connection reaches, with the connection that reaches it. */
+export interface Zone {
+    readonly connectionId: string;
+    readonly provider: string;
+    readonly target: Provider.Target;
+}
+/**
+ * A connection's standing in a zone listing. `reconnect` is a credential the provider turned down:
+ * the connection is still the owner's, and the other connections' zones came back regardless.
+ */
+export interface ZoneConnection {
+    readonly connectionId: string;
+    readonly provider: string;
+    readonly status: "connected" | "reconnect";
+}
+/** Every zone the principal's connections reach, and how each connection is standing. */
+export interface Zones {
+    /** Ordered by zone, then by connection, so two listings of the same state read the same. */
+    readonly zones: ReadonlyArray<Zone>;
+    readonly connections: ReadonlyArray<ZoneConnection>;
+    /** Every provider a customer could connect from here, so an offer needs no second call. */
+    readonly providers: Snapshot["providers"];
+}
 export interface Interface {
     readonly inspect: (domain: string) => Fx<Snapshot>;
+    /**
+     * Every zone the principal's connections can serve, from `Provider.Session.listTargets`. A
+     * connection whose credential the provider turned down is marked `reconnect` in `connections`
+     * and contributes no zones; the rest still list.
+     */
+    readonly zones: (options?: {
+        readonly provider?: string;
+    }) => Fx<Zones>;
     /**
      * Resolve the domain's authoritative nameservers, then match them against the zones each of
      * the principal's connections can reach: the closest zone wins, a decisive nameserver match
@@ -425,6 +458,18 @@ export interface Interface {
         readonly domain?: string;
         readonly callbackUrl?: string;
     }) => Fx<Started>;
+    /**
+     * Replace the credential behind a connection the owner already holds, keeping the connection and
+     * every domain attached to it. This is what a customer means by reconnecting: starting again
+     * would mint a second account and leave the domains on the one the provider turned down. The
+     * provider is the connection's own; a credential for a different account is the customer's
+     * choice, and the zone check on every session catches a zone it can no longer reach.
+     */
+    readonly reconnect: (input: {
+        readonly connectionId: string;
+        readonly method: Method;
+        readonly callbackUrl?: string;
+    }) => Fx<Started>;
     /** Finish an interactive connection from the provider callback (the full callback URL). */
     readonly complete: (input: {
         readonly continuationId: string;
@@ -468,6 +513,9 @@ export declare class Policy extends Policy_base {
 export declare const make: Effect.Effect<Interface, never, Storage.Service | Custody.Service | Providers.Service | Resolver.Service>;
 export declare const layer: Layer.Layer<Service, never, Storage.Service | Custody.Service | Providers.Service | Resolver.Service>;
 export declare const inspect: (domain: string) => Effect.Effect<Snapshot, Errors.DomainKitError, Principal.Service | Service>;
+export declare const zones: (options?: {
+    readonly provider?: string;
+} | undefined) => Effect.Effect<Zones, Errors.DomainKitError, Principal.Service | Service>;
 export declare const discover: (domain: string) => Effect.Effect<{
     readonly _tag: "NotFound";
     readonly nameservers: ReadonlyArray<string>;
@@ -503,6 +551,23 @@ export declare const start: (input: {
     readonly connection: Storage.Connection;
     readonly candidates: ReadonlyArray<Provider.Target>;
 }, Errors.DomainKitError, Principal.Service | Service>;
+export declare const reconnect: (input: {
+    readonly connectionId: string;
+    readonly method: Method;
+    readonly callbackUrl?: string;
+}) => Effect.Effect<{
+    readonly _tag: "Connected";
+    readonly connection: Storage.Connection;
+    readonly attachment: Storage.Attachment | null;
+} | {
+    readonly _tag: "Redirect";
+    readonly authorizationUrl: string;
+    readonly continuationId: string;
+} | {
+    readonly _tag: "SelectionRequired";
+    readonly connection: Storage.Connection;
+    readonly candidates: ReadonlyArray<Provider.Target>;
+}, Errors.DomainKitError, Principal.Service | Service>;
 export declare const complete: (input: {
     readonly continuationId: string;
     readonly callbackUrl: string;

package/dist/types/Provider.d.ts

@@ -170,6 +170,10 @@ export interface MethodDescriptor {
 }
 /** Field descriptors derived from `TokenAuth.fields`: optional keys are not required, `Redacted` values are secret. */
 export declare const tokenFields: (auth: TokenAuth) => ReadonlyArray<FieldDescriptor>;
+/**
+ * Every method a provider offers, in the order a UI should present them: the interactive ones a
+ * customer clicks through first, then the token they have to go and fetch themselves.
+ */
 export declare const describeMethods: (definition: Definition) => ReadonlyArray<MethodDescriptor>;
 export interface CallbackInput {
     readonly code: string;
@@ -240,6 +244,7 @@ export declare const encodeContext: <Context>(definition: Definition<Context>, v
 export type AuthMethod = "token" | "oauth" | "integration";
 /** Validates a definition: an id and at least one auth method. Throws `DomainKit.Error` otherwise. */
 export declare const make: <Context>(definition: Definition<Context>) => Definition<Context>;
+/** The kinds alone, in the same order `describeMethods` puts them: interactive first, token last. */
 export declare const methods: (definition: Definition) => ReadonlyArray<AuthMethod>;
 /**
  * Pick the most specific zone among `targets` for `domain`: exactly one match resolves, several