@distilled.cloud/cloudflare 0.25.2 → 0.26.0

package/src/services/pipelines.ts

@@ -17,103 +17,125 @@ import { SensitiveString } from "../sensitive.ts";
 // Errors
 // =============================================================================
 
-export class InvalidSinkConfig extends Schema.TaggedErrorClass<InvalidSinkConfig>()(
-  "InvalidSinkConfig",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidSinkConfig extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidSinkConfig>()("InvalidSinkConfig", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1012 }],
 ) {}
-T.applyErrorMatchers(InvalidSinkConfig, [{ code: 1012 }]);
 
-export class InvalidSinkId extends Schema.TaggedErrorClass<InvalidSinkId>()(
-  "InvalidSinkId",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidSinkId extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidSinkId>()("InvalidSinkId", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 2 }],
 ) {}
-T.applyErrorMatchers(InvalidSinkId, [{ code: 2 }]);
 
-export class InvalidSql extends Schema.TaggedErrorClass<InvalidSql>()(
-  "InvalidSql",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidSql extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidSql>()("InvalidSql", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1014 }],
 ) {}
-T.applyErrorMatchers(InvalidSql, [{ code: 1014 }]);
 
-export class InvalidStreamId extends Schema.TaggedErrorClass<InvalidStreamId>()(
-  "InvalidStreamId",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidStreamId extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidStreamId>()("InvalidStreamId", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 2 }],
 ) {}
-T.applyErrorMatchers(InvalidStreamId, [{ code: 2 }]);
 
-export class InvalidStreamName extends Schema.TaggedErrorClass<InvalidStreamName>()(
-  "InvalidStreamName",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidStreamName extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidStreamName>()("InvalidStreamName", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 2 }],
 ) {}
-T.applyErrorMatchers(InvalidStreamName, [{ code: 2 }]);
 
-export class PipelineAlreadyExists extends Schema.TaggedErrorClass<PipelineAlreadyExists>()(
-  "PipelineAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class PipelineAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<PipelineAlreadyExists>()("PipelineAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1003 }],
 ) {}
-T.applyErrorMatchers(PipelineAlreadyExists, [{ code: 1003 }]);
 
-export class PipelineNotExists extends Schema.TaggedErrorClass<PipelineNotExists>()(
-  "PipelineNotExists",
-  { code: Schema.Number, message: Schema.String },
+export class PipelineNotExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<PipelineNotExists>()("PipelineNotExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1000 }],
 ) {}
-T.applyErrorMatchers(PipelineNotExists, [{ code: 1000 }]);
 
-export class SinkAlreadyExists extends Schema.TaggedErrorClass<SinkAlreadyExists>()(
-  "SinkAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class SinkAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SinkAlreadyExists>()("SinkAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1003 }],
 ) {}
-T.applyErrorMatchers(SinkAlreadyExists, [{ code: 1003 }]);
 
-export class SinkAuthFailed extends Schema.TaggedErrorClass<SinkAuthFailed>()(
-  "SinkAuthFailed",
-  { code: Schema.Number, message: Schema.String },
+export class SinkAuthFailed extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SinkAuthFailed>()("SinkAuthFailed", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1012, message: { includes: "could not authenticate" } }],
 ) {}
-T.applyErrorMatchers(SinkAuthFailed, [
-  { code: 1012, message: { includes: "could not authenticate" } },
-]);
 
-export class SinkInUse extends Schema.TaggedErrorClass<SinkInUse>()(
-  "SinkInUse",
-  { code: Schema.Number, message: Schema.String },
+export class SinkInUse extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SinkInUse>()("SinkInUse", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 422, message: { includes: "in use" } }],
 ) {}
-T.applyErrorMatchers(SinkInUse, [
-  { status: 422, message: { includes: "in use" } },
-]);
 
-export class SinkNotFound extends Schema.TaggedErrorClass<SinkNotFound>()(
-  "SinkNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class SinkNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SinkNotFound>()("SinkNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1015 }],
 ) {}
-T.applyErrorMatchers(SinkNotFound, [{ code: 1015 }]);
 
-export class StreamAlreadyExists extends Schema.TaggedErrorClass<StreamAlreadyExists>()(
-  "StreamAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class StreamAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<StreamAlreadyExists>()("StreamAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1003 }],
 ) {}
-T.applyErrorMatchers(StreamAlreadyExists, [{ code: 1003 }]);
 
-export class StreamInUse extends Schema.TaggedErrorClass<StreamInUse>()(
-  "StreamInUse",
-  { code: Schema.Number, message: Schema.String },
+export class StreamInUse extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<StreamInUse>()("StreamInUse", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 422, message: { includes: "in use" } }],
 ) {}
-T.applyErrorMatchers(StreamInUse, [
-  { status: 422, message: { includes: "in use" } },
-]);
 
-export class StreamNotFound extends Schema.TaggedErrorClass<StreamNotFound>()(
-  "StreamNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class StreamNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<StreamNotFound>()("StreamNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1016 }],
 ) {}
-T.applyErrorMatchers(StreamNotFound, [{ code: 1016 }]);
 
-export class TableNotFound extends Schema.TaggedErrorClass<TableNotFound>()(
-  "TableNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class TableNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TableNotFound>()("TableNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1014, message: { includes: "not found" } }],
 ) {}
-T.applyErrorMatchers(TableNotFound, [
-  { code: 1014, message: { includes: "not found" } },
-]);
 
 // =============================================================================
 // Pipeline

package/src/services/queues.ts

@@ -16,121 +16,145 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class ConsumerAlreadyExists extends Schema.TaggedErrorClass<ConsumerAlreadyExists>()(
-  "ConsumerAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class ConsumerAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ConsumerAlreadyExists>()("ConsumerAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 11004 }],
 ) {}
-T.applyErrorMatchers(ConsumerAlreadyExists, [{ code: 11004 }]);
 
-export class ConsumerNotFound extends Schema.TaggedErrorClass<ConsumerNotFound>()(
-  "ConsumerNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class ConsumerNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ConsumerNotFound>()("ConsumerNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10013 }, { code: 10105 }, { code: 11006 }],
 ) {}
-T.applyErrorMatchers(ConsumerNotFound, [
-  { code: 10013 },
-  { code: 10105 },
-  { code: 11006 },
-]);
-
-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 InvalidMessageBody extends Schema.TaggedErrorClass<InvalidMessageBody>()(
-  "InvalidMessageBody",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidMessageBody extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidMessageBody>()("InvalidMessageBody", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10207 }, { code: 10013 }],
 ) {}
-T.applyErrorMatchers(InvalidMessageBody, [{ code: 10207 }, { code: 10013 }]);
 
-export class InvalidQueueId extends Schema.TaggedErrorClass<InvalidQueueId>()(
-  "InvalidQueueId",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidQueueId extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidQueueId>()("InvalidQueueId", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10107 }],
 ) {}
-T.applyErrorMatchers(InvalidQueueId, [{ code: 10107 }]);
 
-export class InvalidQueueName extends Schema.TaggedErrorClass<InvalidQueueName>()(
-  "InvalidQueueName",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidQueueName extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidQueueName>()("InvalidQueueName", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 11003 }],
 ) {}
-T.applyErrorMatchers(InvalidQueueName, [{ code: 11003 }]);
 
-export class InvalidRequestBody extends Schema.TaggedErrorClass<InvalidRequestBody>()(
-  "InvalidRequestBody",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidRequestBody extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidRequestBody>()("InvalidRequestBody", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10026 }],
 ) {}
-T.applyErrorMatchers(InvalidRequestBody, [{ code: 10026 }]);
 
-export class InvalidRoute extends Schema.TaggedErrorClass<InvalidRoute>()(
-  "InvalidRoute",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidRoute extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidRoute>()("InvalidRoute", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 7003 }],
 ) {}
-T.applyErrorMatchers(InvalidRoute, [{ code: 7003 }]);
 
-export class QueueAlreadyExists extends Schema.TaggedErrorClass<QueueAlreadyExists>()(
-  "QueueAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class QueueAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<QueueAlreadyExists>()("QueueAlreadyExists", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 11009 }],
 ) {}
-T.applyErrorMatchers(QueueAlreadyExists, [{ code: 11009 }]);
 
-export class QueueHandlerMissing extends Schema.TaggedErrorClass<QueueHandlerMissing>()(
-  "QueueHandlerMissing",
-  { code: Schema.Number, message: Schema.String },
+export class QueueHandlerMissing extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<QueueHandlerMissing>()("QueueHandlerMissing", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [
+    { code: 11001 },
+    { status: 400, message: { includes: "queue handler is missing" } },
+  ],
 ) {}
-T.applyErrorMatchers(QueueHandlerMissing, [
-  { code: 11001 },
-  { status: 400, message: { includes: "queue handler is missing" } },
-]);
-
-export class QueueInUseByEventNotification extends Schema.TaggedErrorClass<QueueInUseByEventNotification>()(
-  "QueueInUseByEventNotification",
-  { code: Schema.Number, message: Schema.String },
+
+export class QueueInUseByEventNotification extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<QueueInUseByEventNotification>()(
+    "QueueInUseByEventNotification",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 11017 }],
 ) {}
-T.applyErrorMatchers(QueueInUseByEventNotification, [{ code: 11017 }]);
 
-export class QueueNotFound extends Schema.TaggedErrorClass<QueueNotFound>()(
-  "QueueNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class QueueNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<QueueNotFound>()("QueueNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [
+    { code: 11000 },
+    { code: 0, message: { includes: "Queue does not exist" } },
+    { status: 404, message: { includes: "Queue does not exist" } },
+  ],
 ) {}
-T.applyErrorMatchers(QueueNotFound, [
-  { code: 11000 },
-  { code: 0, message: { includes: "Queue does not exist" } },
-  { status: 404, message: { includes: "Queue does not exist" } },
-]);
-
-export class SubscriptionAlreadyExists extends Schema.TaggedErrorClass<SubscriptionAlreadyExists>()(
-  "SubscriptionAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+
+export class SubscriptionAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SubscriptionAlreadyExists>()(
+    "SubscriptionAlreadyExists",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [
+    {
+      status: 405,
+      message: { includes: "do not support multiple subscriptions" },
+    },
+  ],
 ) {}
-T.applyErrorMatchers(SubscriptionAlreadyExists, [
-  {
-    status: 405,
-    message: { includes: "do not support multiple subscriptions" },
-  },
-]);
-
-export class SubscriptionNotFound extends Schema.TaggedErrorClass<SubscriptionNotFound>()(
-  "SubscriptionNotFound",
-  { code: Schema.Number, message: Schema.String },
+
+export class SubscriptionNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SubscriptionNotFound>()("SubscriptionNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 404, message: { includes: "No subscription with this ID" } }],
 ) {}
-T.applyErrorMatchers(SubscriptionNotFound, [
-  { status: 404, message: { includes: "No subscription with this ID" } },
-]);
 
-export class UnrecognizedEventType extends Schema.TaggedErrorClass<UnrecognizedEventType>()(
-  "UnrecognizedEventType",
-  { code: Schema.Number, message: Schema.String },
+export class UnrecognizedEventType extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<UnrecognizedEventType>()("UnrecognizedEventType", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 0, message: { includes: "Unrecognized event types" } }],
 ) {}
-T.applyErrorMatchers(UnrecognizedEventType, [
-  { code: 0, message: { includes: "Unrecognized event types" } },
-]);
 
-export class WorkerNotFound extends Schema.TaggedErrorClass<WorkerNotFound>()(
-  "WorkerNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class WorkerNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WorkerNotFound>()("WorkerNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10007 }],
 ) {}
-T.applyErrorMatchers(WorkerNotFound, [{ code: 10007 }]);
 
 // =============================================================================
 // Consumer

package/src/services/r2-data-catalog.ts

@@ -16,47 +16,61 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-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 InvalidCredential extends Schema.TaggedErrorClass<InvalidCredential>()(
-  "InvalidCredential",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidCredential extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidCredential>()("InvalidCredential", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 30004 }, { code: 30005 }],
 ) {}
-T.applyErrorMatchers(InvalidCredential, [{ code: 30004 }, { code: 30005 }]);
 
-export class InvalidRoute extends Schema.TaggedErrorClass<InvalidRoute>()(
-  "InvalidRoute",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidRoute extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidRoute>()("InvalidRoute", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 7003 }],
 ) {}
-T.applyErrorMatchers(InvalidRoute, [{ code: 7003 }]);
 
-export class NoSuchBucket extends Schema.TaggedErrorClass<NoSuchBucket>()(
-  "NoSuchBucket",
-  { code: Schema.Number, message: Schema.String },
+export class NoSuchBucket extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<NoSuchBucket>()("NoSuchBucket", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10006 }, { code: 40406 }],
 ) {}
-T.applyErrorMatchers(NoSuchBucket, [{ code: 10006 }, { code: 40406 }]);
 
-export class TableNotFound extends Schema.TaggedErrorClass<TableNotFound>()(
-  "TableNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class TableNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TableNotFound>()("TableNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10001 }, { code: 40403 }],
 ) {}
-T.applyErrorMatchers(TableNotFound, [{ code: 10001 }, { code: 40403 }]);
 
-export class WarehouseInactive extends Schema.TaggedErrorClass<WarehouseInactive>()(
-  "WarehouseInactive",
-  { code: Schema.Number, message: Schema.String },
+export class WarehouseInactive extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WarehouseInactive>()("WarehouseInactive", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 40402 }],
 ) {}
-T.applyErrorMatchers(WarehouseInactive, [{ code: 40402 }]);
 
-export class WarehouseNotFound extends Schema.TaggedErrorClass<WarehouseNotFound>()(
-  "WarehouseNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class WarehouseNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WarehouseNotFound>()("WarehouseNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 40401 }],
 ) {}
-T.applyErrorMatchers(WarehouseNotFound, [{ code: 40401 }]);
 
 // =============================================================================
 // Credential