@distilled.cloud/cloudflare 0.25.2 → 0.26.0

package/src/services/zones.ts

@@ -16,70 +16,89 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class CustomNameserverSetNotFound extends Schema.TaggedErrorClass<CustomNameserverSetNotFound>()(
-  "CustomNameserverSetNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class CustomNameserverSetNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<CustomNameserverSetNotFound>()(
+    "CustomNameserverSetNotFound",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [
+    {
+      code: 1001,
+      message: { includes: "Custom Nameserver set doesn't exist" },
+    },
+  ],
 ) {}
-T.applyErrorMatchers(CustomNameserverSetNotFound, [
-  { code: 1001, message: { includes: "Custom Nameserver set doesn't exist" } },
-]);
 
-export class DomainNotRegistered extends Schema.TaggedErrorClass<DomainNotRegistered>()(
-  "DomainNotRegistered",
-  { code: Schema.Number, message: Schema.String },
+export class DomainNotRegistered extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<DomainNotRegistered>()("DomainNotRegistered", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1099 }],
 ) {}
-T.applyErrorMatchers(DomainNotRegistered, [{ code: 1099 }]);
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class InvalidDomain extends Schema.TaggedErrorClass<InvalidDomain>()(
-  "InvalidDomain",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidDomain extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidDomain>()("InvalidDomain", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1002 }],
 ) {}
-T.applyErrorMatchers(InvalidDomain, [{ code: 1002 }]);
 
-export class InvalidZoneIdentifier extends Schema.TaggedErrorClass<InvalidZoneIdentifier>()(
-  "InvalidZoneIdentifier",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidZoneIdentifier extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidZoneIdentifier>()("InvalidZoneIdentifier", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 9109, message: { includes: "Invalid zone identifier" } }],
 ) {}
-T.applyErrorMatchers(InvalidZoneIdentifier, [
-  { code: 9109, message: { includes: "Invalid zone identifier" } },
-]);
 
-export class SubdomainNotAllowed extends Schema.TaggedErrorClass<SubdomainNotAllowed>()(
-  "SubdomainNotAllowed",
-  { code: Schema.Number, message: Schema.String },
+export class SubdomainNotAllowed extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SubdomainNotAllowed>()("SubdomainNotAllowed", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1116 }],
 ) {}
-T.applyErrorMatchers(SubdomainNotAllowed, [{ code: 1116 }]);
 
-export class ZoneAlreadyExists extends Schema.TaggedErrorClass<ZoneAlreadyExists>()(
-  "ZoneAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class ZoneAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ZoneAlreadyExists>()("ZoneAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1061 }],
 ) {}
-T.applyErrorMatchers(ZoneAlreadyExists, [{ code: 1061 }]);
 
-export class ZoneHoldNotFound extends Schema.TaggedErrorClass<ZoneHoldNotFound>()(
-  "ZoneHoldNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class ZoneHoldNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ZoneHoldNotFound>()("ZoneHoldNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1003, message: { includes: "No Zone Hold Found" } }],
 ) {}
-T.applyErrorMatchers(ZoneHoldNotFound, [
-  { code: 1003, message: { includes: "No Zone Hold Found" } },
-]);
 
-export class ZoneHoldsRequireEnterprise extends Schema.TaggedErrorClass<ZoneHoldsRequireEnterprise>()(
-  "ZoneHoldsRequireEnterprise",
-  { code: Schema.Number, message: Schema.String },
+export class ZoneHoldsRequireEnterprise extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ZoneHoldsRequireEnterprise>()(
+    "ZoneHoldsRequireEnterprise",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [
+    {
+      code: 1005,
+      message: {
+        includes: "Zone holds are only available on Enterprise zones",
+      },
+    },
+  ],
 ) {}
-T.applyErrorMatchers(ZoneHoldsRequireEnterprise, [
-  {
-    code: 1005,
-    message: { includes: "Zone holds are only available on Enterprise zones" },
-  },
-]);
 
 // =============================================================================
 // ActivationCheck

package/src/traits.ts

@@ -22,16 +22,33 @@ export interface ErrorMatcher {
 }
 
 /**
- * Apply error matchers directly to a class's AST annotations.
- * Used for TaggedErrorClass where .pipe() on a class returns a schema
- * (not a class), breaking `extends ... .pipe(...)`.
+ * Apply error matchers to a class's AST annotations, returning the class so it
+ * can be used directly in an `extends` clause:
+ *
+ * ```ts
+ * export class Foo extends T.applyErrorMatchers(
+ *   Schema.TaggedErrorClass<Foo>()("Foo", { ... }),
+ *   [{ code: 1234 }],
+ * ) {}
+ * ```
+ *
+ * Mutating the base class's annotations propagates to the subclass — Effect's
+ * Class API reuses the same AST reference — so matchers stay readable via
+ * `getErrorMatchers(Foo.ast)`. Returning the class (instead of running as a
+ * void top-level statement) keeps the module free of bare side-effect
+ * statements, so the bundler can tree-shake unused error classes out of Worker
+ * bundles.
+ *
+ * `.pipe()` is deliberately not used: piping a class returns a schema (not a
+ * class), which can't appear in an `extends` clause.
  */
-export const applyErrorMatchers = (
-  cls: { ast: AST.AST },
+export const applyErrorMatchers = <C extends { ast: AST.AST }>(
+  cls: C,
   matchers: ErrorMatcher[],
-): void => {
+): C => {
   const annotations = cls.ast.annotations as Record<symbol, unknown>;
   annotations[errorMatchersSymbol] = matchers;
+  return cls;
 };
 
 export const getErrorMatchers = (ast: AST.AST) =>