domainkit 0.10.0 → 0.12.0

package/dist/types/Storage.d.ts

@@ -60,6 +60,8 @@ declare const Attachment_base: Schema.Class<Attachment, Schema.Struct<{
     readonly connectionId: Schema.String;
     readonly domain: Schema.String;
     readonly zone: Schema.String;
+    /** The target's label as the provider gave it at attach time, so a UI names the account without a provider call. */
+    readonly label: Schema.String;
     /** Provider zone identity (zone id, account id) decoded by the provider's `context` schema. */
     readonly target: Schema.Unknown;
     readonly createdAt: Schema.DateTimeUtcFromString;
@@ -178,6 +180,7 @@ export interface Interface {
             readonly connectionId: string;
             readonly domain: string;
             readonly zone: string;
+            readonly label: string;
             readonly target: unknown;
         }) => Fx<Attachment>;
         readonly get: (id: string) => Fx<Attachment>;
@@ -273,6 +276,7 @@ export interface AsyncInterface {
             readonly connectionId: string;
             readonly domain: string;
             readonly zone: string;
+            readonly label: string;
             readonly target: unknown;
         }) => Promise<Attachment>;
         readonly get: (principal: Principal.Interface, id: string) => Promise<Attachment>;

package/dist/types/Testing.d.ts

@@ -16,8 +16,12 @@ export declare const storage: Layer.Layer<Storage.Service>;
 export declare const principal: Principal.Interface;
 export interface FakeProviderOptions {
     readonly id?: string;
+    /** The name a customer reads. Default `Fake <id>`; a fixture that ships screenshots sets it. */
+    readonly name?: string;
     /** Zones the fake credential can reach. Default: `example.com`. */
     readonly zones?: ReadonlyArray<string>;
+    /** The label each zone carries, keyed by zone. Default: the zone name. */
+    readonly labels?: Readonly<Record<string, string>>;
     /** Pre-existing records, to produce `Noop` and `Conflict` operations. */
     readonly records?: ReadonlyArray<{
         readonly zone: string;
@@ -49,18 +53,23 @@ type FakeContext = typeof Context.Type;
 export declare const provider: (options?: FakeProviderOptions) => FakeProvider;
 /** Records every fake provider currently holds for `name`, across all fake zones. */
 export declare const fakeRecords: (name: string) => ReadonlyArray<DnsRecord.Observed>;
+export interface FakeResolverOptions {
+    /** The name every answer carries. A UI reads it as the observer. Default `fake`. */
+    readonly id?: string;
+}
 /**
- * A resolver answering from the fake providers' zones, or from an explicit table. Every answer
- * is attributed to the resolver named `fake`.
+ * A resolver answering from the fake providers' zones, or from an explicit table. Every answer is
+ * attributed to `options.id`, which a fixture that ships screenshots names after a real resolver.
  */
 export declare const resolver: (answers?: ReadonlyArray<{
     readonly name: string;
     readonly records: ReadonlyArray<DnsRecord.Observed>;
-}>) => Layer.Layer<Resolver.Service>;
+}>, options?: FakeResolverOptions) => Layer.Layer<Resolver.Service>;
 export interface TransportOptions {
     /** Which groups the fake server exposes, so a UI can be tested against a partial host. */
     readonly capabilities?: ReadonlyArray<Transport.Capability>;
     readonly provider?: FakeProviderOptions;
+    readonly resolver?: FakeResolverOptions;
 }
 export interface RecordedCall {
     /** `connection.inspect`, `provisioning.approve`, ... */

package/dist/types/Transport.d.ts

@@ -23,6 +23,9 @@ export type Readiness = Server.Readiness;
 export type Attempt = Server.Attempt;
 export type Candidate = Server.Candidate;
 export type Discovery = Server.Discovery;
+export type Zone = Server.Zone;
+export type Zones = Server.Zones;
+export type Attachment = Server.Attachment;
 export type Field = Server.Field;
 export type MethodDescriptor = Server.MethodDescriptor;
 export type Method = Server.Method;
@@ -41,11 +44,21 @@ export interface ConnectionGroup {
     readonly inspect: (domain: string) => Fx<Snapshot>;
     /** Which of this owner's existing connections already reaches the domain. */
     readonly discover: (domain: string) => Fx<Discovery>;
+    /** Every zone this owner's connections reach, and where each connection stands. */
+    readonly zones: (options?: {
+        readonly provider?: string;
+    }) => Fx<Zones>;
+    /** Connect a provider. Without a domain the account connects alone and attaches nothing. */
     readonly start: (input: {
-        readonly domain: string;
+        readonly domain?: string;
         readonly provider: string;
         readonly method: Method;
     }) => Fx<Started>;
+    /** Prove an account again for a connection this owner holds, keeping its domains. */
+    readonly reconnect: (input: {
+        readonly connectionId: string;
+        readonly method: Method;
+    }) => Fx<Started>;
     readonly attach: (input: {
         readonly connectionId: string;
         readonly domain: string;
@@ -71,6 +84,8 @@ export interface ProvisioningGroup {
     readonly apply: (approvalId: Approval.ApprovalId) => Fx<Receipt.Model>;
     /** The stored plan with its status, approval, receipt, and rejection. */
     readonly attempt: (planId: Plan.PlanId) => Fx<Attempt>;
+    /** What one apply landed, by receipt id, for a surface that holds the id and not the attempt. */
+    readonly receipt: (receiptId: Receipt.ReceiptId) => Fx<Receipt.Model>;
 }
 export interface VerificationGroup {
     /**

package/dist/types/internal/oauth.d.ts

@@ -41,6 +41,8 @@ export declare const exchangeCode: (input: {
     readonly callbackUrl: string;
     readonly codeVerifier: string;
     readonly fetch?: Fetch;
+    /** Permit an `http:` endpoint that is not loopback. Development only; see `insecureAllowed`. */
+    readonly allowPlaintext?: boolean;
 }) => Effect.Effect<Tokens, Errors.DomainKitError>;
 export declare const refresh: (input: {
     readonly provider: string;
@@ -48,6 +50,7 @@ export declare const refresh: (input: {
     readonly client: Client;
     readonly refreshToken: string;
     readonly fetch?: Fetch;
+    readonly allowPlaintext?: boolean;
 }) => Effect.Effect<Tokens, Errors.DomainKitError>;
 export declare const revoke: (input: {
     readonly provider: string;
@@ -55,4 +58,5 @@ export declare const revoke: (input: {
     readonly client: Client;
     readonly token: string;
     readonly fetch?: Fetch;
+    readonly allowPlaintext?: boolean;
 }) => Effect.Effect<void, Errors.DomainKitError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domainkit",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Build reviewable DNS plans for custom domains in TypeScript",
   "keywords": [
     "custom-domains",