@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/functions/CallableError.d.mts

@@ -0,0 +1,297 @@
+import { Schema } from "effect";
+declare namespace CallableError_d_exports {
+  export { AlreadyExists, CallableError, DecodeError, EncodeError, ErrorCode, FailedPrecondition, InvalidArgument, NotFound, PermissionDenied, Reason, ResourceExhausted, ResponseError, TransportError, Unauthenticated, Unavailable };
+}
+/**
+ * Firebase's error codes, as `firebase-functions` and the client SDK name
+ * them, without `ok`.
+ *
+ * @stability unstable
+ * @category schemas
+ * @since 0.3.0
+ */
+export declare const ErrorCode: Schema.Literals<readonly ["cancelled", "unknown", "invalid-argument", "deadline-exceeded", "not-found", "already-exists", "permission-denied", "resource-exhausted", "failed-precondition", "aborted", "out-of-range", "unimplemented", "internal", "unavailable", "data-loss", "unauthenticated"]>;
+/**
+ * One of Firebase's error codes, such as `not-found`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type ErrorCode = typeof ErrorCode.Type;
+declare module "effect/Schema" {
+  namespace Annotations {
+    interface Annotations {
+      /**
+       * The Firebase error code a Callable answers with when it fails with
+       * this error. Set it with `Callable.errorCode` or in a `TaggedError`'s
+       * annotations, and read it with `Callable.getErrorCode`.
+       */
+      readonly callableErrorCode?: ErrorCode | undefined;
+    }
+  }
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The resource the call asks for doesn't exist. Its code is `not-found`.
+ *
+ * @example Failing with a built-in error
+ * ```ts
+ * import { Effect, Schema } from "effect";
+ * import { Callable, CallableError } from "@visiolab/effect-firebase/functions";
+ *
+ * const GetUser = Callable.make("getUser", {
+ *   payload: { id: Schema.String },
+ *   success: Schema.String,
+ *   error: CallableError.NotFound,
+ * });
+ *
+ * const GetUserLive = Callable.toLayer(GetUser, ({ id }) =>
+ *   Effect.fail(new CallableError.NotFound({ message: `No user ${id}` })),
+ * );
+ * ```
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class NotFound extends NotFound_base {}
+declare const PermissionDenied_base: Schema.Class<PermissionDenied, Schema.TaggedStruct<"PermissionDenied", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The caller may not do what the call asks. Its code is `permission-denied`.
+ *
+ * @see {@link Unauthenticated} for a caller who isn't signed in
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class PermissionDenied extends PermissionDenied_base {}
+declare const Unauthenticated_base: Schema.Class<Unauthenticated, Schema.TaggedStruct<"Unauthenticated", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The caller isn't signed in. Its code is `unauthenticated`.
+ *
+ * @see {@link PermissionDenied} for a signed-in caller who may not do this
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class Unauthenticated extends Unauthenticated_base {}
+declare const InvalidArgument_base: Schema.Class<InvalidArgument, Schema.TaggedStruct<"InvalidArgument", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The Payload is well-formed but its values are wrong. Its code is
+ * `invalid-argument`.
+ *
+ * **Details**
+ *
+ * A Payload that doesn't decode is answered with `invalid-argument` already,
+ * without this error. Use it for checks the Payload's schema can't express.
+ *
+ * @see {@link FailedPrecondition} for a valid Payload the current state rejects
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class InvalidArgument extends InvalidArgument_base {}
+declare const AlreadyExists_base: Schema.Class<AlreadyExists, Schema.TaggedStruct<"AlreadyExists", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * What the call would create exists already. Its code is `already-exists`.
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class AlreadyExists extends AlreadyExists_base {}
+declare const FailedPrecondition_base: Schema.Class<FailedPrecondition, Schema.TaggedStruct<"FailedPrecondition", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The system isn't in the state the call needs. Its code is
+ * `failed-precondition`.
+ *
+ * @see {@link InvalidArgument} for a Payload that is wrong whatever the state
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class FailedPrecondition extends FailedPrecondition_base {}
+declare const ResourceExhausted_base: Schema.Class<ResourceExhausted, Schema.TaggedStruct<"ResourceExhausted", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * A quota or rate limit ran out. Its code is `resource-exhausted`.
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class ResourceExhausted extends ResourceExhausted_base {}
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The service can't answer right now, and the call may succeed if retried.
+ * Its code is `unavailable`.
+ *
+ * @stability unstable
+ * @category built-in errors
+ * @since 0.3.0
+ */
+export declare class Unavailable extends Unavailable_base {}
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"TransportError", {
+  /** What the SDK threw. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * No response arrived: the request never reached the server, the connection
+ * broke before it answered, or the client gave up waiting.
+ *
+ * **Details**
+ *
+ * The client SDK appends the HTTP status of an answer to its error's message
+ * as ` [<status>]`, and reports a network failure as status 0. The errors the
+ * SDK makes itself carry no status: its timeout (`deadline-exceeded`), a
+ * cancelled call, and a deleted Functions instance. `CallableClient` treats
+ * an error without a status, or with status 0, as a `TransportError`, except
+ * for an answer the SDK can't read, which is a {@link DecodeError}.
+ *
+ * @see {@link ResponseError} for an error the server answered with
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare class TransportError extends TransportError_base {}
+declare const ResponseError_base: Schema.Class<ResponseError, Schema.TaggedStruct<"ResponseError", {
+  /** Firebase's error code, such as `internal`. */
+  readonly code: Schema.Literals<readonly ["cancelled", "unknown", "invalid-argument", "deadline-exceeded", "not-found", "already-exists", "permission-denied", "resource-exhausted", "failed-precondition", "aborted", "out-of-range", "unimplemented", "internal", "unavailable", "data-loss", "unauthenticated"]>;
+  /** The error's message, without the SDK's ` [status]` suffix. */
+  readonly message: Schema.String;
+  /** The error's `details`, as the server sent them. */
+  readonly details: Schema.Unknown;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The server answered with an error the contract doesn't declare.
+ *
+ * **Details**
+ *
+ * `code` is Firebase's error code without its `functions/` prefix, such as
+ * `not-found`. `not-found` usually means the client calls the wrong region or
+ * a name the server doesn't export.
+ *
+ * Only an error the server answered with, with a non-zero HTTP status, is a
+ * `ResponseError`. A `deadline-exceeded` the server sends is one; the client
+ * SDK's own timeout, which has the same code, is a {@link TransportError}.
+ *
+ * @see {@link TransportError} for a call no answer arrived for
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare class ResponseError extends ResponseError_base {}
+declare const EncodeError_base: Schema.Class<EncodeError, Schema.TaggedStruct<"EncodeError", {
+  /** The `Schema.SchemaError` of the encode. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The Payload didn't encode through its `Schema.toCodecJson`, so nothing was
+ * sent.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare class EncodeError extends EncodeError_base {}
+declare const DecodeError_base: Schema.Class<DecodeError, Schema.TaggedStruct<"DecodeError", {
+  /** The `Schema.SchemaError` of the decode. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The server's answer didn't decode against the contract, as after the server
+ * and the client drift apart.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare class DecodeError extends DecodeError_base {}
+/**
+ * What went wrong with a call, as one of the reasons above.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type Reason = TransportError | ResponseError | EncodeError | DecodeError;
+declare const CallableError_base: Schema.Class<CallableError, Schema.TaggedStruct<"CallableError", {
+  /** The deployed name of the Callable Function that was called. */
+  readonly callable: Schema.String;
+  /** What went wrong. */
+  readonly reason: Schema.Union<readonly [typeof TransportError, typeof ResponseError, typeof EncodeError, typeof DecodeError]>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * A call to a Callable failed in a way the contract doesn't declare.
+ *
+ * **When to use**
+ *
+ * Use `Effect.catchReason` on its `reason` to recover from one kind of
+ * failure, such as a missing response.
+ *
+ * @example Recovering from a missing response
+ * ```ts
+ * import { Effect } from "effect";
+ * import type { CallableError } from "@visiolab/effect-firebase/functions";
+ *
+ * declare const call: Effect.Effect<string, CallableError.CallableError>;
+ *
+ * const program = call.pipe(
+ *   Effect.catchReason("CallableError", "TransportError", () => Effect.succeed("offline")),
+ * );
+ * ```
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare class CallableError extends CallableError_base {}
+export { CallableError_d_exports };

package/dist/functions/CallableError.mjs

@@ -0,0 +1,256 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { Schema } from "effect";
+// src/functions/CallableError.ts
+/**
+* Errors of Callables: Firebase's error codes, built-in errors that carry
+* them, and the error a Callable Client fails with when a call goes wrong in a
+* way the contract doesn't declare.
+*
+* @stability unstable
+* @since 0.3.0
+*/
+var CallableError_exports = /* @__PURE__ */ __exportAll({
+	AlreadyExists: () => AlreadyExists,
+	CallableError: () => CallableError,
+	DecodeError: () => DecodeError,
+	EncodeError: () => EncodeError,
+	ErrorCode: () => ErrorCode,
+	FailedPrecondition: () => FailedPrecondition,
+	InvalidArgument: () => InvalidArgument,
+	NotFound: () => NotFound,
+	PermissionDenied: () => PermissionDenied,
+	ResourceExhausted: () => ResourceExhausted,
+	ResponseError: () => ResponseError,
+	TransportError: () => TransportError,
+	Unauthenticated: () => Unauthenticated,
+	Unavailable: () => Unavailable
+});
+/**
+* Firebase's error codes, as `firebase-functions` and the client SDK name
+* them, without `ok`.
+*
+* @stability unstable
+* @category schemas
+* @since 0.3.0
+*/
+const ErrorCode = Schema.Literals([
+	"cancelled",
+	"unknown",
+	"invalid-argument",
+	"deadline-exceeded",
+	"not-found",
+	"already-exists",
+	"permission-denied",
+	"resource-exhausted",
+	"failed-precondition",
+	"aborted",
+	"out-of-range",
+	"unimplemented",
+	"internal",
+	"unavailable",
+	"data-loss",
+	"unauthenticated"
+]);
+/**
+* The resource the call asks for doesn't exist. Its code is `not-found`.
+*
+* @example Failing with a built-in error
+* ```ts
+* import { Effect, Schema } from "effect";
+* import { Callable, CallableError } from "@visiolab/effect-firebase/functions";
+*
+* const GetUser = Callable.make("getUser", {
+*   payload: { id: Schema.String },
+*   success: Schema.String,
+*   error: CallableError.NotFound,
+* });
+*
+* const GetUserLive = Callable.toLayer(GetUser, ({ id }) =>
+*   Effect.fail(new CallableError.NotFound({ message: `No user ${id}` })),
+* );
+* ```
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var NotFound = class extends Schema.TaggedError()("NotFound", { message: Schema.optional(Schema.String) }, { callableErrorCode: "not-found" }) {};
+/**
+* The caller may not do what the call asks. Its code is `permission-denied`.
+*
+* @see {@link Unauthenticated} for a caller who isn't signed in
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var PermissionDenied = class extends Schema.TaggedError()("PermissionDenied", { message: Schema.optional(Schema.String) }, { callableErrorCode: "permission-denied" }) {};
+/**
+* The caller isn't signed in. Its code is `unauthenticated`.
+*
+* @see {@link PermissionDenied} for a signed-in caller who may not do this
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var Unauthenticated = class extends Schema.TaggedError()("Unauthenticated", { message: Schema.optional(Schema.String) }, { callableErrorCode: "unauthenticated" }) {};
+/**
+* The Payload is well-formed but its values are wrong. Its code is
+* `invalid-argument`.
+*
+* **Details**
+*
+* A Payload that doesn't decode is answered with `invalid-argument` already,
+* without this error. Use it for checks the Payload's schema can't express.
+*
+* @see {@link FailedPrecondition} for a valid Payload the current state rejects
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var InvalidArgument = class extends Schema.TaggedError()("InvalidArgument", { message: Schema.optional(Schema.String) }, { callableErrorCode: "invalid-argument" }) {};
+/**
+* What the call would create exists already. Its code is `already-exists`.
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var AlreadyExists = class extends Schema.TaggedError()("AlreadyExists", { message: Schema.optional(Schema.String) }, { callableErrorCode: "already-exists" }) {};
+/**
+* The system isn't in the state the call needs. Its code is
+* `failed-precondition`.
+*
+* @see {@link InvalidArgument} for a Payload that is wrong whatever the state
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var FailedPrecondition = class extends Schema.TaggedError()("FailedPrecondition", { message: Schema.optional(Schema.String) }, { callableErrorCode: "failed-precondition" }) {};
+/**
+* A quota or rate limit ran out. Its code is `resource-exhausted`.
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var ResourceExhausted = class extends Schema.TaggedError()("ResourceExhausted", { message: Schema.optional(Schema.String) }, { callableErrorCode: "resource-exhausted" }) {};
+/**
+* The service can't answer right now, and the call may succeed if retried.
+* Its code is `unavailable`.
+*
+* @stability unstable
+* @category built-in errors
+* @since 0.3.0
+*/
+var Unavailable = class extends Schema.TaggedError()("Unavailable", { message: Schema.optional(Schema.String) }, { callableErrorCode: "unavailable" }) {};
+/**
+* No response arrived: the request never reached the server, the connection
+* broke before it answered, or the client gave up waiting.
+*
+* **Details**
+*
+* The client SDK appends the HTTP status of an answer to its error's message
+* as ` [<status>]`, and reports a network failure as status 0. The errors the
+* SDK makes itself carry no status: its timeout (`deadline-exceeded`), a
+* cancelled call, and a deleted Functions instance. `CallableClient` treats
+* an error without a status, or with status 0, as a `TransportError`, except
+* for an answer the SDK can't read, which is a {@link DecodeError}.
+*
+* @see {@link ResponseError} for an error the server answered with
+*
+* @stability unstable
+* @category errors
+* @since 0.3.0
+*/
+var TransportError = class extends Schema.TaggedError()("TransportError", { 
+/** What the SDK threw. */
+cause: Schema.Defect() }) {};
+/**
+* The server answered with an error the contract doesn't declare.
+*
+* **Details**
+*
+* `code` is Firebase's error code without its `functions/` prefix, such as
+* `not-found`. `not-found` usually means the client calls the wrong region or
+* a name the server doesn't export.
+*
+* Only an error the server answered with, with a non-zero HTTP status, is a
+* `ResponseError`. A `deadline-exceeded` the server sends is one; the client
+* SDK's own timeout, which has the same code, is a {@link TransportError}.
+*
+* @see {@link TransportError} for a call no answer arrived for
+*
+* @stability unstable
+* @category errors
+* @since 0.3.0
+*/
+var ResponseError = class extends Schema.TaggedError()("ResponseError", {
+	/** Firebase's error code, such as `internal`. */
+	code: ErrorCode,
+	/** The error's message, without the SDK's ` [status]` suffix. */
+	message: Schema.String,
+	/** The error's `details`, as the server sent them. */
+	details: Schema.Unknown
+}) {};
+/**
+* The Payload didn't encode through its `Schema.toCodecJson`, so nothing was
+* sent.
+*
+* @stability unstable
+* @category errors
+* @since 0.3.0
+*/
+var EncodeError = class extends Schema.TaggedError()("EncodeError", { 
+/** The `Schema.SchemaError` of the encode. */
+cause: Schema.Defect() }) {};
+/**
+* The server's answer didn't decode against the contract, as after the server
+* and the client drift apart.
+*
+* @stability unstable
+* @category errors
+* @since 0.3.0
+*/
+var DecodeError = class extends Schema.TaggedError()("DecodeError", { 
+/** The `Schema.SchemaError` of the decode. */
+cause: Schema.Defect() }) {};
+/**
+* A call to a Callable failed in a way the contract doesn't declare.
+*
+* **When to use**
+*
+* Use `Effect.catchReason` on its `reason` to recover from one kind of
+* failure, such as a missing response.
+*
+* @example Recovering from a missing response
+* ```ts
+* import { Effect } from "effect";
+* import type { CallableError } from "@visiolab/effect-firebase/functions";
+*
+* declare const call: Effect.Effect<string, CallableError.CallableError>;
+*
+* const program = call.pipe(
+*   Effect.catchReason("CallableError", "TransportError", () => Effect.succeed("offline")),
+* );
+* ```
+*
+* @stability unstable
+* @category errors
+* @since 0.3.0
+*/
+var CallableError = class extends Schema.TaggedError()("CallableError", {
+	/** The deployed name of the Callable Function that was called. */
+	callable: Schema.String,
+	/** What went wrong. */
+	reason: Schema.Union([
+		TransportError,
+		ResponseError,
+		EncodeError,
+		DecodeError
+	])
+}) {};
+export { AlreadyExists, CallableError, CallableError_exports, DecodeError, EncodeError, ErrorCode, FailedPrecondition, InvalidArgument, NotFound, PermissionDenied, ResourceExhausted, ResponseError, TransportError, Unauthenticated, Unavailable };