@visiolab/effect-firebase 0.0.0-stage → 0.3.1

package/src/firestore/internal/timestamp.ts

@@ -0,0 +1,119 @@
+import {
+  DateTime,
+  Effect,
+  Equal,
+  Hash,
+  Inspectable,
+  Option,
+  Order as order,
+  Predicate,
+} from "effect";
+import type * as Timestamp from "../Timestamp.ts";
+
+/** @internal */
+export const TypeId = "~@visiolab/effect-firebase/firestore/Timestamp";
+
+/** `0001-01-01T00:00:00Z`, the earliest instant Firestore addresses. */
+const minSeconds = -62_135_596_800;
+/** `9999-12-31T23:59:59Z`, the latest. */
+const maxSeconds = 253_402_300_799;
+const maxNanoseconds = 999_999_999;
+const nanosecondsPerMillisecond = 1_000_000;
+
+/** Kept apart from the guards below, which narrow a `number` to `never`. */
+const inSecondsRange = (n: number): boolean =>
+  Number.isInteger(n) && n >= minSeconds && n <= maxSeconds;
+
+const inNanosecondsRange = (n: number): boolean =>
+  Number.isInteger(n) && n >= 0 && n <= maxNanoseconds;
+
+/** @internal */
+export const isTimestamp = (u: unknown): u is Timestamp.Timestamp =>
+  Predicate.hasProperty(u, TypeId) &&
+  u[TypeId] === TypeId &&
+  Predicate.hasProperty(u, "seconds") &&
+  Predicate.hasProperty(u, "nanoseconds") &&
+  Predicate.isNumber(u.seconds) &&
+  Predicate.isNumber(u.nanoseconds) &&
+  inSecondsRange(u.seconds) &&
+  inNanosecondsRange(u.nanoseconds);
+
+const Proto: Omit<Timestamp.Timestamp, "seconds" | "nanoseconds"> = {
+  ...Inspectable.BaseProto,
+  [TypeId]: TypeId,
+  toJSON(this: Timestamp.Timestamp) {
+    return { _id: "Timestamp", seconds: this.seconds, nanoseconds: this.nanoseconds };
+  },
+  [Equal.symbol](this: Timestamp.Timestamp, that: unknown): boolean {
+    return (
+      isTimestamp(that) && this.seconds === that.seconds && this.nanoseconds === that.nanoseconds
+    );
+  },
+  [Hash.symbol](this: Timestamp.Timestamp): number {
+    return Hash.combine(Hash.number(this.seconds), Hash.number(this.nanoseconds));
+  },
+};
+
+const makeUnchecked = (seconds: number, nanoseconds: number): Timestamp.Timestamp =>
+  Object.assign(Object.create(Proto) as typeof Proto, { seconds, nanoseconds });
+
+/** @internal */
+export const makeUnsafe = (seconds: number, nanoseconds: number): Timestamp.Timestamp => {
+  if (!inSecondsRange(seconds)) {
+    throw new Error(
+      `Invalid Firestore timestamp: seconds must be an integer between ${minSeconds} and ${maxSeconds}, got ${seconds}`,
+    );
+  }
+  if (!inNanosecondsRange(nanoseconds)) {
+    throw new Error(
+      `Invalid Firestore timestamp: nanoseconds must be an integer between 0 and ${maxNanoseconds}, got ${nanoseconds}`,
+    );
+  }
+  return makeUnchecked(seconds, nanoseconds);
+};
+
+/** @internal */
+export const make = (seconds: number, nanoseconds: number): Option.Option<Timestamp.Timestamp> =>
+  inSecondsRange(seconds) && inNanosecondsRange(nanoseconds)
+    ? Option.some(makeUnchecked(seconds, nanoseconds))
+    : Option.none();
+
+/** Splits milliseconds into the second and the fraction of it Firestore stores. */
+const partsOfMillis = (millis: number): readonly [seconds: number, nanoseconds: number] => {
+  const seconds = Math.floor(millis / 1000);
+  return [seconds, Math.floor((millis - seconds * 1000) * nanosecondsPerMillisecond)];
+};
+
+/** @internal */
+export const fromMillisUnsafe = (millis: number): Timestamp.Timestamp =>
+  makeUnsafe(...partsOfMillis(millis));
+
+/** @internal */
+export const fromMillis = (millis: number): Option.Option<Timestamp.Timestamp> =>
+  make(...partsOfMillis(millis));
+
+/** @internal */
+export const fromDateTimeUnsafe = (dateTime: DateTime.Utc): Timestamp.Timestamp =>
+  fromMillisUnsafe(DateTime.toEpochMillis(dateTime));
+
+/** @internal */
+export const fromDateTime = (dateTime: DateTime.Utc): Option.Option<Timestamp.Timestamp> =>
+  fromMillis(DateTime.toEpochMillis(dateTime));
+
+/** @internal */
+export const now: Effect.Effect<Timestamp.Timestamp> = Effect.map(DateTime.now, fromDateTimeUnsafe);
+
+/** @internal */
+export const toMillis = (self: Timestamp.Timestamp): number =>
+  self.seconds * 1000 + Math.floor(self.nanoseconds / nanosecondsPerMillisecond);
+
+/** @internal */
+export const toDateTime = (self: Timestamp.Timestamp): DateTime.Utc =>
+  DateTime.makeUnsafe(toMillis(self));
+
+/** @internal */
+export const Order: order.Order<Timestamp.Timestamp> = order.make((self, that) =>
+  self.seconds === that.seconds
+    ? order.Number(self.nanoseconds, that.nanoseconds)
+    : order.Number(self.seconds, that.seconds),
+);

package/src/firestore/internal/timestampSchema.ts

@@ -0,0 +1,42 @@
+/**
+ * Apart from the other Firestore schemas, so that deriving `toCodecFirestore`,
+ * which writes instants as timestamps, need not import the schemas that
+ * derive it in turn.
+ */
+import { Effect, Equal, Schema, SchemaGetter, SchemaIssue } from "effect";
+import type * as FirestoreSchema from "../FirestoreSchema.ts";
+import type * as Timestamp_ from "../Timestamp.ts";
+import * as timestamp from "./timestamp.ts";
+
+/** Writes a timestamp as JSON without losing the digits finer than a millisecond. */
+const TimestampJson = Schema.Struct({ seconds: Schema.Int, nanoseconds: Schema.Int });
+
+/** @internal */
+export const Timestamp: FirestoreSchema.Timestamp = Schema.declare<Timestamp_.Timestamp>(
+  timestamp.isTimestamp,
+  {
+    representation: { id: "@visiolab/effect-firebase/firestore/Timestamp", payload: null },
+    expected: "a Firestore Timestamp",
+    toEquivalence: () => Equal.equals,
+    toCodecFirestore: () => undefined,
+    toCodecJson: () =>
+      Schema.link<Timestamp_.Timestamp>()(TimestampJson, {
+        decode: SchemaGetter.transformEffect((json: typeof TimestampJson.Type, options) =>
+          Effect.fromOption(timestamp.make(json.seconds, json.nanoseconds)).pipe(
+            Effect.mapError(
+              () =>
+                new SchemaIssue.InvalidValue(
+                  { message: "Expected an instant Firestore can store" },
+                  json,
+                  options,
+                ),
+            ),
+          ),
+        ),
+        encode: SchemaGetter.transform((value: Timestamp_.Timestamp) => ({
+          seconds: value.seconds,
+          nanoseconds: value.nanoseconds,
+        })),
+      }),
+  },
+);

package/src/firestore/internal/transactionFromCallback.ts

@@ -0,0 +1,106 @@
+import { Cause, Effect, Exit, Option } from "effect";
+import { constVoid } from "effect/Function";
+import type * as Firestore from "../Firestore.ts";
+import { FirestoreError } from "./firestoreError.ts";
+
+/**
+ * What the callback throws when the body fails with anything but a
+ * `FirestoreError` that carries its backend's cause.
+ *
+ * It carries no `code` on purpose: an SDK decides whether to retry by the code
+ * of what it caught, and a body's own error that happens to carry one would
+ * otherwise be retried as if Firestore had raised it.
+ */
+class BodyFailed {
+  readonly cause: Cause.Cause<unknown>;
+  constructor(cause: Cause.Cause<unknown>) {
+    this.cause = cause;
+  }
+}
+
+/**
+ * What the callback throws for a body that failed with `cause`.
+ *
+ * A `FirestoreError` goes back as the SDK's own error behind it, so the SDK
+ * decides by its own rules whether to retry it - a read answered with ABORTED
+ * under contention, or an outage that passes - rather than by a copy of them
+ * kept here. Anything else goes back as {@link BodyFailed}, which it never
+ * retries.
+ */
+const thrownFor = (cause: Cause.Cause<unknown>): unknown => {
+  const error = Option.getOrUndefined(Cause.findErrorOption(cause));
+  return error instanceof FirestoreError && error.cause !== undefined
+    ? error.cause
+    : new BodyFailed(cause);
+};
+
+/** @internal */
+export const transactionFromCallback = <
+  T,
+  Operations extends Firestore.TransactionOperations,
+  TransactionServices = never,
+>(
+  options: Firestore.TransactionFromCallbackOptions<T, Operations, TransactionServices>,
+): Firestore.RunTransaction<Operations, TransactionServices> => ({
+  run: (body, hookOptions) => runOver(options, body, hookOptions),
+  context: options.context,
+});
+
+/** Runs `body` in a transaction through `options.run`, once per attempt. */
+const runOver = <T, Operations extends Firestore.TransactionOperations, A, E>(
+  options: Pick<
+    Firestore.TransactionFromCallbackOptions<T, Operations>,
+    "run" | "operations" | "onError"
+  >,
+  body: (operations: Operations) => Effect.Effect<A, E>,
+  hookOptions: Firestore.TransactionHookOptions,
+): Effect.Effect<A, E | FirestoreError> =>
+  Effect.uninterruptibleMask((restore) => {
+    const controller = new AbortController();
+    // The last thing the body failed with, and what was thrown for it, so
+    // that a failure the SDK hands back without retrying it comes back as
+    // the body's own rather than wrapped.
+    let failure: { readonly thrown: unknown; readonly cause: Cause.Cause<unknown> } | undefined;
+    const callback = async (transaction: unknown): Promise<A> => {
+      // The body has everything it needs provided, so it runs on a runtime
+      // of its own here, inside the SDK's callback. `run` hands this the
+      // SDK's transaction, which `operations` is typed by: `run`'s callback
+      // is not, so that `T` is inferred from `operations` alone.
+      const operations = options.operations(transaction as T);
+      const exit = await Effect.runPromiseExit(body(operations), {
+        signal: controller.signal,
+      });
+      if (Exit.isSuccess(exit)) return exit.value;
+      const thrown = thrownFor(exit.cause);
+      failure = { thrown, cause: exit.cause };
+      throw thrown;
+    };
+    let running: Promise<A>;
+    try {
+      running = options.run(callback, hookOptions);
+    } catch (cause) {
+      running = Promise.reject(cause);
+    }
+
+    return restore(
+      Effect.tryPromise({
+        try: () => running,
+        catch: (cause) =>
+          failure !== undefined && cause === failure.thrown
+            ? new BodyFailed(failure.cause)
+            : options.onError(cause),
+      }),
+    ).pipe(
+      // Interrupting the body is what makes the callback reject, and so what
+      // makes the SDK roll back - which is waited for, so that nothing of
+      // the transaction is left running once this is done.
+      Effect.onInterrupt(() => {
+        controller.abort();
+        return Effect.promise(() => running.then(constVoid, constVoid));
+      }),
+      Effect.catchIf(
+        (error): error is BodyFailed => error instanceof BodyFailed,
+        (failed) => Effect.failCause(failed.cause as Cause.Cause<E>),
+      ),
+    );
+  });