domainkit 0.8.0 → 0.9.0

package/dist/types/Reason.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Why an operation failed. Every `DomainKit.Error` carries exactly one of these as `reason`; hosts
+ * match on `reason._tag` and add a reason here rather than a new error class.
+ */
+import { Schema } from "effect";
+import * as Plan from "./Plan.ts";
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<"InvalidInput", {
+    readonly message: Schema.String;
+    readonly field: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidInput extends InvalidInput_base {
+}
+declare const Unauthenticated_base: Schema.Class<Unauthenticated, Schema.TaggedStruct<"Unauthenticated", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class Unauthenticated extends Unauthenticated_base {
+}
+declare const Forbidden_base: Schema.Class<Forbidden, Schema.TaggedStruct<"Forbidden", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+    readonly entity: Schema.Literals<readonly ["connection", "attachment", "plan", "approval", "receipt", "continuation", "provider", "zone", "authorization", "record"]>;
+    readonly id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFound extends NotFound_base {
+    get message(): string;
+}
+declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
+    readonly planId: Schema.suspend<Schema.brand<Schema.String, "@domainkit/PlanId">>;
+    readonly operations: Schema.suspend<Schema.$Array<typeof Plan.Conflict>>;
+}>, import("effect/Cause").YieldableError>;
+/** The plan contains conflicts and cannot be applied. */
+export declare class Conflict extends Conflict_base {
+    get message(): string;
+}
+declare const Stale_base: Schema.Class<Stale, Schema.TaggedStruct<"Stale", {
+    readonly planId: Schema.suspend<Schema.brand<Schema.String, "@domainkit/PlanId">>;
+    readonly digest: Schema.suspend<Schema.brand<Schema.String, "@domainkit/Digest">>;
+}>, import("effect/Cause").YieldableError>;
+/** Provider state moved since the plan was built; build a new plan. */
+export declare class Stale extends Stale_base {
+    get message(): string;
+}
+declare const Expired_base: Schema.Class<Expired, Schema.TaggedStruct<"Expired", {
+    readonly entity: Schema.Literals<readonly ["plan", "approval", "continuation", "credential"]>;
+    readonly id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class Expired extends Expired_base {
+    get message(): string;
+}
+declare const Busy_base: Schema.Class<Busy, Schema.TaggedStruct<"Busy", {
+    readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Another operation holds the lock (e.g. concurrent apply or refresh). Retrying is safe. */
+export declare class Busy extends Busy_base {
+    get message(): string;
+}
+declare const ProviderRejected_base: Schema.Class<ProviderRejected, Schema.TaggedStruct<"ProviderRejected", {
+    readonly provider: Schema.String;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderRejected extends ProviderRejected_base {
+}
+declare const ProviderUnavailable_base: Schema.Class<ProviderUnavailable, Schema.TaggedStruct<"ProviderUnavailable", {
+    readonly provider: Schema.String;
+    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderUnavailable extends ProviderUnavailable_base {
+}
+declare const Reconnect_base: Schema.Class<Reconnect, Schema.TaggedStruct<"Reconnect", {
+    readonly provider: Schema.String;
+    readonly connectionId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The provider credential no longer works; the customer must reconnect. */
+export declare class Reconnect extends Reconnect_base {
+    get message(): string;
+}
+declare const StorageFailed_base: Schema.Class<StorageFailed, Schema.TaggedStruct<"StorageFailed", {
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class StorageFailed extends StorageFailed_base {
+}
+declare const CryptoFailed_base: Schema.Class<CryptoFailed, Schema.TaggedStruct<"CryptoFailed", {
+    readonly operation: Schema.Literals<readonly ["digest", "seal", "open"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class CryptoFailed extends CryptoFailed_base {
+    get message(): string;
+}
+declare const ResolverFailed_base: Schema.Class<ResolverFailed, Schema.TaggedStruct<"ResolverFailed", {
+    readonly resolver: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResolverFailed extends ResolverFailed_base {
+}
+declare const ProviderConflict_base: Schema.Class<ProviderConflict, Schema.TaggedStruct<"ProviderConflict", {
+    readonly provider: Schema.String;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The provider refused the write because a conflicting record already exists there. */
+export declare class ProviderConflict extends ProviderConflict_base {
+}
+declare const Unsupported_base: Schema.Class<Unsupported, Schema.TaggedStruct<"Unsupported", {
+    readonly provider: Schema.String;
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The provider, or this target within it, cannot do the requested operation. */
+export declare class Unsupported extends Unsupported_base {
+}
+export declare const Model: Schema.Union<readonly [typeof InvalidInput, typeof Unauthenticated, typeof Forbidden, typeof NotFound, typeof Conflict, typeof Stale, typeof Expired, typeof Busy, typeof ProviderRejected, typeof ProviderUnavailable, typeof ProviderConflict, typeof Unsupported, typeof Reconnect, typeof StorageFailed, typeof CryptoFailed, typeof ResolverFailed]>;
+export type Model = typeof Model.Type;
+export {};

package/dist/types/Receipt.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What actually happened when an approval was applied. Partial application is a normal outcome
+ * carried here as `status: "partial"`, never an error. Cleanup plans are built only from receipts.
+ */
+import { Effect, Schema } from "effect";
+import * as Errors from "./internal/error.ts";
+export declare const ReceiptId: Schema.brand<Schema.String, "@domainkit/ReceiptId">;
+export type ReceiptId = typeof ReceiptId.Type;
+declare const Applied_base: Schema.Class<Applied, Schema.TaggedStruct<"Applied", {
+    readonly operationId: Schema.brand<Schema.String, "@domainkit/OperationId">;
+    /** The record created (provisioning) or deleted (cleanup). */
+    readonly providerRecordId: Schema.String;
+}>, {}>;
+export declare class Applied extends Applied_base {
+}
+declare const Skipped_base: Schema.Class<Skipped, Schema.TaggedStruct<"Skipped", {
+    readonly operationId: Schema.brand<Schema.String, "@domainkit/OperationId">;
+    readonly reason: Schema.Literals<readonly ["noop", "not-approved", "not-attempted"]>;
+}>, {}>;
+/**
+ * `noop`: the record already existed. `not-approved`: the approval excluded the operation.
+ * `not-attempted`: an earlier operation failed and apply stopped before reaching this one.
+ */
+export declare class Skipped extends Skipped_base {
+}
+declare const Failed_base: Schema.Class<Failed, Schema.TaggedStruct<"Failed", {
+    readonly operationId: Schema.brand<Schema.String, "@domainkit/OperationId">;
+    readonly message: Schema.String;
+}>, {}>;
+export declare class Failed extends Failed_base {
+}
+export declare const Outcome: Schema.Union<readonly [typeof Applied, typeof Skipped, typeof Failed]>;
+export type Outcome = typeof Outcome.Type;
+declare const Model_base: Schema.Class<Model, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "@domainkit/ReceiptId">;
+    readonly version: Schema.Literal<"domainkit.receipt.v2">;
+    readonly kind: Schema.Literals<readonly ["provisioning", "cleanup"]>;
+    readonly planId: Schema.brand<Schema.String, "@domainkit/PlanId">;
+    readonly approvalId: Schema.brand<Schema.String, "@domainkit/ApprovalId">;
+    readonly digest: Schema.brand<Schema.String, "@domainkit/Digest">;
+    readonly provider: Schema.String;
+    readonly zone: Schema.String;
+    readonly status: Schema.Literals<readonly ["complete", "partial"]>;
+    readonly outcomes: Schema.$Array<Schema.Union<readonly [typeof Applied, typeof Skipped, typeof Failed]>>;
+    readonly appliedAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+export declare class Model extends Model_base {
+}
+export type Encoded = typeof Model.Encoded;
+export declare const decode: (input: unknown) => Effect.Effect<Model, Errors.DomainKitError>;
+export declare const encode: (receipt: Model) => Encoded;
+export declare const isComplete: (receipt: Model) => boolean;
+/** Operations the receipt proves were written, with the provider record ids needed to undo them. */
+export declare const applied: (receipt: Model) => ReadonlyArray<Applied>;
+export {};

package/dist/types/Resolver.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Public DNS observation. The default layer fans out to Cloudflare and Google DNS-over-HTTPS and
+ * keeps every answer, so verification can show "found at Cloudflare, missing at Google".
+ */
+import { Context, Data, Effect, Layer } from "effect";
+import type * as DnsRecord from "./DnsRecord.ts";
+import * as Errors from "./internal/error.ts";
+import type { Fetch } from "./internal/http.ts";
+export interface Answer {
+    readonly resolver: string;
+    readonly records: ReadonlyArray<DnsRecord.Observed>;
+    readonly negative: boolean;
+    readonly ttl: number | null;
+}
+export type Outcome = Data.TaggedEnum<{
+    Answered: {
+        readonly answer: Answer;
+    };
+    Failed: {
+        readonly resolver: string;
+        readonly message: string;
+    };
+    TimedOut: {
+        readonly resolver: string;
+    };
+}>;
+export declare const Outcome: {
+    readonly $is: <Tag extends "Answered" | "Failed" | "TimedOut">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Answered";
+        readonly answer: Answer;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Failed";
+        readonly resolver: string;
+        readonly message: string;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "TimedOut";
+        readonly resolver: string;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "Answered" | "Failed" | "TimedOut"]: (args: Extract<{
+            readonly _tag: "Answered";
+            readonly answer: Answer;
+        } | {
+            readonly _tag: "Failed";
+            readonly resolver: string;
+            readonly message: string;
+        } | {
+            readonly _tag: "TimedOut";
+            readonly resolver: string;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "Answered";
+            readonly answer: Answer;
+        } | {
+            readonly _tag: "Failed";
+            readonly resolver: string;
+            readonly message: string;
+        } | {
+            readonly _tag: "TimedOut";
+            readonly resolver: string;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Answered" | "Failed" | "TimedOut"]>>;
+        <Cases extends { readonly [Tag in "Answered" | "Failed" | "TimedOut"]: (args: Extract<{
+            readonly _tag: "Answered";
+            readonly answer: Answer;
+        } | {
+            readonly _tag: "Failed";
+            readonly resolver: string;
+            readonly message: string;
+        } | {
+            readonly _tag: "TimedOut";
+            readonly resolver: string;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "Answered";
+            readonly answer: Answer;
+        } | {
+            readonly _tag: "Failed";
+            readonly resolver: string;
+            readonly message: string;
+        } | {
+            readonly _tag: "TimedOut";
+            readonly resolver: string;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Answered" | "Failed" | "TimedOut"]>>;
+    };
+    readonly Answered: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Answered";
+        readonly answer: Answer;
+    }, "_tag">;
+    readonly Failed: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Failed";
+        readonly resolver: string;
+        readonly message: string;
+    }, "_tag">;
+    readonly TimedOut: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "TimedOut";
+        readonly resolver: string;
+    }, "_tag">;
+};
+export interface Interface {
+    /** Never fails: each resolver's outcome is preserved. */
+    readonly resolve: (name: string, type: DnsRecord.Type, options?: {
+        readonly signal?: AbortSignal | undefined;
+    }) => Effect.Effect<ReadonlyArray<Outcome>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@domainkit/Resolver", Interface>;
+export declare class Service extends Service_base {
+}
+export interface Endpoint {
+    readonly name: string;
+    readonly url: string;
+}
+export interface Options {
+    readonly endpoints?: ReadonlyArray<Endpoint>;
+    readonly timeoutMs?: number;
+    readonly fetch?: Fetch;
+}
+export declare const cloudflare: Endpoint;
+export declare const google: Endpoint;
+export declare const defaults: {
+    readonly endpoints: readonly [Endpoint, Endpoint];
+    readonly timeoutMs: 3000;
+};
+export declare const make: (options?: Options) => Effect.Effect<Interface, Errors.DomainKitError>;
+/** Cloudflare + Google DoH, 3s timeout. */
+export declare const layer: Layer.Layer<Service>;
+export declare const layerWith: (options: Options) => Layer.Layer<Service, Errors.DomainKitError>;
+export {};