@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/firestore/internal/streamFromListener.mjs

@@ -0,0 +1,12 @@
+import { Cause, Effect, Queue, Result, Stream } from "effect";
+// src/firestore/internal/streamFromListener.ts
+/** @internal */
+const streamFromListener = (options) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => options.subscribe((snapshot) => {
+	const element = options.map(snapshot);
+	if (Result.isSuccess(element)) Queue.offerUnsafe(queue, element.success);
+	else Queue.failCauseUnsafe(queue, Cause.fail(element.failure));
+}, (error) => Queue.failCauseUnsafe(queue, Cause.fail(options.onError(error))))), (unsubscribe) => Effect.sync(unsubscribe)), {
+	bufferSize: 1,
+	strategy: "sliding"
+});
+export { streamFromListener };

package/dist/firestore/internal/timestamp.d.mts

@@ -0,0 +1,4 @@
+import { Timestamp } from "../Timestamp.mjs";
+import { DateTime, Effect, Option, Order } from "effect";
+/** @internal */
+export declare const isTimestamp: (u: unknown) => u is Timestamp;

package/dist/firestore/internal/timestamp.mjs

@@ -0,0 +1,66 @@
+import { DateTime, Effect, Equal, Hash, Inspectable, Option, Order, Predicate } from "effect";
+// src/firestore/internal/timestamp.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/Timestamp";
+/** `0001-01-01T00:00:00Z`, the earliest instant Firestore addresses. */
+const minSeconds = -62135596800;
+/** `9999-12-31T23:59:59Z`, the latest. */
+const maxSeconds = 253402300799;
+const maxNanoseconds = 999999999;
+const nanosecondsPerMillisecond = 1e6;
+/** Kept apart from the guards below, which narrow a `number` to `never`. */
+const inSecondsRange = (n) => Number.isInteger(n) && n >= minSeconds && n <= maxSeconds;
+const inNanosecondsRange = (n) => Number.isInteger(n) && n >= 0 && n <= maxNanoseconds;
+/** @internal */
+const isTimestamp = (u) => Predicate.hasProperty(u, "~@visiolab/effect-firebase/firestore/Timestamp") && u["~@visiolab/effect-firebase/firestore/Timestamp"] === "~@visiolab/effect-firebase/firestore/Timestamp" && Predicate.hasProperty(u, "seconds") && Predicate.hasProperty(u, "nanoseconds") && Predicate.isNumber(u.seconds) && Predicate.isNumber(u.nanoseconds) && inSecondsRange(u.seconds) && inNanosecondsRange(u.nanoseconds);
+const Proto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "Timestamp",
+			seconds: this.seconds,
+			nanoseconds: this.nanoseconds
+		};
+	},
+	[Equal.symbol](that) {
+		return isTimestamp(that) && this.seconds === that.seconds && this.nanoseconds === that.nanoseconds;
+	},
+	[Hash.symbol]() {
+		return Hash.combine(Hash.number(this.seconds), Hash.number(this.nanoseconds));
+	}
+};
+const makeUnchecked = (seconds, nanoseconds) => Object.assign(Object.create(Proto), {
+	seconds,
+	nanoseconds
+});
+/** @internal */
+const makeUnsafe = (seconds, nanoseconds) => {
+	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 */
+const make = (seconds, nanoseconds) => 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) => {
+	const seconds = Math.floor(millis / 1e3);
+	return [seconds, Math.floor((millis - seconds * 1e3) * nanosecondsPerMillisecond)];
+};
+/** @internal */
+const fromMillisUnsafe = (millis) => makeUnsafe(...partsOfMillis(millis));
+/** @internal */
+const fromMillis = (millis) => make(...partsOfMillis(millis));
+/** @internal */
+const fromDateTimeUnsafe = (dateTime) => fromMillisUnsafe(DateTime.toEpochMillis(dateTime));
+/** @internal */
+const fromDateTime = (dateTime) => fromMillis(DateTime.toEpochMillis(dateTime));
+/** @internal */
+const now = Effect.map(DateTime.now, fromDateTimeUnsafe);
+/** @internal */
+const toMillis = (self) => self.seconds * 1e3 + Math.floor(self.nanoseconds / nanosecondsPerMillisecond);
+/** @internal */
+const toDateTime = (self) => DateTime.makeUnsafe(toMillis(self));
+/** @internal */
+const Order$1 = Order.make((self, that) => self.seconds === that.seconds ? Order.Number(self.nanoseconds, that.nanoseconds) : Order.Number(self.seconds, that.seconds));
+export { Order$1 as Order, TypeId, fromDateTime, fromDateTimeUnsafe, fromMillis, fromMillisUnsafe, isTimestamp, make, makeUnsafe, now, toDateTime, toMillis };

package/dist/firestore/internal/timestampSchema.mjs

@@ -0,0 +1,31 @@
+import { isTimestamp, make } from "./timestamp.mjs";
+import { Effect, Equal, Schema, SchemaGetter, SchemaIssue } from "effect";
+// src/firestore/internal/timestampSchema.ts
+/**
+* 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.
+*/
+/** Writes a timestamp as JSON without losing the digits finer than a millisecond. */
+const TimestampJson = Schema.Struct({
+	seconds: Schema.Int,
+	nanoseconds: Schema.Int
+});
+/** @internal */
+const Timestamp = Schema.declare(isTimestamp, {
+	representation: {
+		id: "@visiolab/effect-firebase/firestore/Timestamp",
+		payload: null
+	},
+	expected: "a Firestore Timestamp",
+	toEquivalence: () => Equal.equals,
+	toCodecFirestore: () => void 0,
+	toCodecJson: () => Schema.link()(TimestampJson, {
+		decode: SchemaGetter.transformEffect((json, options) => Effect.fromOption(make(json.seconds, json.nanoseconds)).pipe(Effect.mapError(() => new SchemaIssue.InvalidValue({ message: "Expected an instant Firestore can store" }, json, options)))),
+		encode: SchemaGetter.transform((value) => ({
+			seconds: value.seconds,
+			nanoseconds: value.nanoseconds
+		}))
+	})
+});
+export { Timestamp };

package/dist/firestore/internal/transactionFromCallback.mjs

@@ -0,0 +1,66 @@
+import { FirestoreError } from "./firestoreError.mjs";
+import { Cause, Effect, Exit, Option } from "effect";
+import { constVoid } from "effect/Function";
+// src/firestore/internal/transactionFromCallback.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.
+*/
+var BodyFailed = class {
+	cause;
+	constructor(cause) {
+		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) => {
+	const error = Option.getOrUndefined(Cause.findErrorOption(cause));
+	return error instanceof FirestoreError && error.cause !== void 0 ? error.cause : new BodyFailed(cause);
+};
+/** @internal */
+const transactionFromCallback = (options) => ({
+	run: (body, hookOptions) => runOver(options, body, hookOptions),
+	context: options.context
+});
+/** Runs `body` in a transaction through `options.run`, once per attempt. */
+const runOver = (options, body, hookOptions) => Effect.uninterruptibleMask((restore) => {
+	const controller = new AbortController();
+	let failure;
+	const callback = async (transaction) => {
+		const operations = options.operations(transaction);
+		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;
+	try {
+		running = options.run(callback, hookOptions);
+	} catch (cause) {
+		running = Promise.reject(cause);
+	}
+	return restore(Effect.tryPromise({
+		try: () => running,
+		catch: (cause) => failure !== void 0 && cause === failure.thrown ? new BodyFailed(failure.cause) : options.onError(cause)
+	})).pipe(Effect.onInterrupt(() => {
+		controller.abort();
+		return Effect.promise(() => running.then(constVoid, constVoid));
+	}), Effect.catchIf((error) => error instanceof BodyFailed, (failed) => Effect.failCause(failed.cause)));
+});
+export { transactionFromCallback };