@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/firestore/internal/collection.mjs

@@ -0,0 +1,156 @@
+import { isDocumentSnapshot } from "./documentSnapshot.mjs";
+import { Equal, Hash, Inspectable, Option, Predicate, Schema } from "effect";
+// src/firestore/internal/collection.ts
+/** @internal */
+const CollectionTypeId = "~@visiolab/effect-firebase/firestore/Collection";
+/** @internal */
+const CollectionReferenceTypeId = "~@visiolab/effect-firebase/firestore/CollectionReference";
+/** @internal */
+const DocumentReferenceTypeId = "~@visiolab/effect-firebase/firestore/DocumentReference";
+/** @internal */
+const isCollection = (u) => Predicate.hasProperty(u, CollectionTypeId);
+/** @internal */
+const isCollectionReference = (u) => Predicate.hasProperty(u, CollectionReferenceTypeId);
+/** @internal */
+const isDocumentReference = (u) => Predicate.hasProperty(u, DocumentReferenceTypeId);
+const encoder = new TextEncoder();
+/** Rejects the segments Firestore cannot address, before they reach a path. */
+const validateSegment = (segment) => {
+	const reject = (reason) => {
+		throw new Error(`Invalid Firestore collection id "${segment}": ${reason}`);
+	};
+	if (segment.length === 0) reject("it must not be empty");
+	if (segment.includes("/")) reject("it must not contain \"/\"");
+	if (segment === "." || segment === "..") reject("it must not be \".\" or \"..\"");
+	if (/^__.*__$/.test(segment)) reject("it must not match \"__.*__\"");
+	if (encoder.encode(segment).length > 1500) reject("it must be at most 1500 bytes");
+};
+/**
+* Brands an id schema with the path addressing it.
+*
+* The path is only known at runtime, and `Schema.brand` rejects an open `string`
+* key. Narrowing the key to a placeholder literal keeps the real path on the
+* annotation: the static brand is erased where `makeCollection` takes the schema
+* as `Schema.Top`, and the public id types are built above it.
+*/
+const brandId = (path) => Schema.String.pipe(Schema.brand(path.join("/")));
+/** Interleaves the segments with the ids addressing them: `a/1/b/2/c`. */
+const joinPath = (segments, ancestors) => {
+	let path = segments[0];
+	for (let i = 0; i < ancestors.length; i++) path += `/${ancestors[i]}/${segments[i + 1]}`;
+	return path;
+};
+const CollectionProto = {
+	...Inspectable.BaseProto,
+	[CollectionTypeId]: CollectionTypeId,
+	toJSON() {
+		return {
+			_id: "Collection",
+			path: this.path.join("/")
+		};
+	},
+	subcollection(segment, schema) {
+		validateSegment(segment);
+		const path = [...this.path, segment];
+		return makeCollection(path, schema, brandId(path));
+	},
+	collection(...ancestors) {
+		return makeCollectionReference(this, ancestors);
+	},
+	doc(...ids) {
+		const parent = makeCollectionReference(this, ids.slice(0, -1));
+		return makeDocumentReference(parent, ids[ids.length - 1]);
+	}
+};
+/**
+* The target is asserted as the prototype rather than as the finished shape, so
+* that the result type is inferred from the fields below. The return annotation
+* then catches a field that is missing, misspelled or of the wrong type -
+* asserting the finished shape up front would check none of the three.
+*/
+const makeCollection = (path, schema, id) => {
+	const self = Object.assign(Object.create(CollectionProto), {
+		path,
+		segment: path[path.length - 1],
+		schema,
+		id,
+		contains: (value) => isDocumentReference(value) ? value.collection === self : isDocumentSnapshot(value) && value.ref.collection === self
+	});
+	return self;
+};
+const CollectionReferenceProto = {
+	...Inspectable.BaseProto,
+	[CollectionReferenceTypeId]: CollectionReferenceTypeId,
+	toJSON() {
+		return {
+			_id: "CollectionReference",
+			path: this.path
+		};
+	},
+	[Equal.symbol](that) {
+		return isCollectionReference(that) && this.path === that.path && this.collection === that.collection;
+	},
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(this.path), Hash.random(this.collection));
+	},
+	doc(id) {
+		return makeDocumentReference(this, id);
+	}
+};
+const makeCollectionReference = (collection, ancestors) => Object.assign(Object.create(CollectionReferenceProto), {
+	collection,
+	ancestors,
+	id: collection.segment,
+	path: joinPath(collection.path, ancestors)
+});
+const DocumentReferenceProto = {
+	...Inspectable.BaseProto,
+	[DocumentReferenceTypeId]: DocumentReferenceTypeId,
+	toJSON() {
+		return {
+			_id: "DocumentReference",
+			path: this.path
+		};
+	},
+	[Equal.symbol](that) {
+		return isDocumentReference(that) && this.path === that.path && this.collection === that.collection;
+	},
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(this.path), Hash.random(this.collection));
+	}
+};
+/** A document is always built from the collection holding it, which it keeps. */
+const makeDocumentReference = (parent, id) => Object.assign(Object.create(DocumentReferenceProto), {
+	collection: parent.collection,
+	ancestors: parent.ancestors,
+	id,
+	path: `${parent.path}/${id}`,
+	parent
+});
+/** @internal */
+const make = (segment, schema) => {
+	validateSegment(segment);
+	const path = [segment];
+	return makeCollection(path, schema, brandId(path));
+};
+/** @internal */
+const fromPath = (collection, path) => {
+	const self = collection;
+	const parts = path.split("/");
+	if (parts.length !== self.path.length * 2) return Option.none();
+	const ids = [];
+	for (let i = 0; i < self.path.length; i++) {
+		const id = parts[2 * i + 1];
+		if (parts[2 * i] !== self.path[i] || id.length === 0) return Option.none();
+		ids.push(id);
+	}
+	return Option.some(self.doc(...ids));
+};
+/**
+* The path a document in `collection` is found at, with `{id}` standing in for
+* each id: `users/{id}/posts/{id}`.
+*
+* @internal
+*/
+const pattern = (collection) => collection.path.map((segment) => `${segment}/{id}`).join("/");
+export { CollectionReferenceTypeId, CollectionTypeId, DocumentReferenceTypeId, fromPath, isCollection, isCollectionReference, isDocumentReference, make, pattern };

package/dist/firestore/internal/collectionGroup.mjs

@@ -0,0 +1,64 @@
+import { UndefinedCollectionError } from "./firestoreError.mjs";
+import { fromPath, pattern } from "./collection.mjs";
+import { Inspectable, Option, Predicate, Result } from "effect";
+// src/firestore/internal/collectionGroup.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/CollectionGroup";
+/** @internal */
+const isCollectionGroup = (u) => Predicate.hasProperty(u, TypeId);
+/**
+* Where `member`'s collections sit, with `{id}` standing in for each ancestor
+* id: `users/{id}/posts`.
+*/
+const memberPattern = (member) => pattern(member).slice(0, -5);
+const CollectionGroupProto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "CollectionGroup",
+			members: this.members.map(memberPattern)
+		};
+	}
+};
+/**
+* Rejects the groups that would not mean one thing: one with nothing in it,
+* one whose collections Firestore could not read under one collection id, and
+* one with two collections at the same path, which no document could be told
+* apart between.
+*/
+const validate = (members) => {
+	const reject = (reason) => {
+		throw new Error(`Invalid collection group: ${reason}`);
+	};
+	if (members.length === 0) reject("it must hold at least one collection");
+	const [first] = members;
+	const seen = /* @__PURE__ */ new Set();
+	for (const member of members) {
+		if (member.segment !== first.segment) reject(`"${memberPattern(first)}" and "${memberPattern(member)}" do not share their collection id`);
+		const pattern = memberPattern(member);
+		if (seen.has(pattern)) reject(`it has more than one member at "${pattern}"`);
+		seen.add(pattern);
+	}
+};
+/** @internal */
+const make = (...valid) => {
+	const members = valid;
+	validate(members);
+	return Object.assign(Object.create(CollectionGroupProto), {
+		members,
+		id: members[0].segment
+	});
+};
+/** @internal */
+const documentAt = (group, path) => {
+	for (const member of group.members) {
+		const ref = fromPath(member, path);
+		if (Option.isSome(ref)) return Result.succeed(ref.value);
+	}
+	return Result.fail(new UndefinedCollectionError({
+		path,
+		collectionId: group.id
+	}));
+};
+export { TypeId, documentAt, isCollectionGroup, make };

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

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

package/dist/firestore/internal/documentPath.mjs

@@ -0,0 +1,42 @@
+import { Equal, Hash, Inspectable, Option, Predicate } from "effect";
+// src/firestore/internal/documentPath.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/DocumentPath";
+/** A collection id, then a document id, and so on: an even number of non-empty segments. */
+const addressesDocument = (path) => {
+	const segments = path.split("/");
+	return segments.length % 2 === 0 && segments.every((segment) => segment.length > 0);
+};
+/** @internal */
+const isDocumentPath = (u) => Predicate.hasProperty(u, "~@visiolab/effect-firebase/firestore/DocumentPath") && u["~@visiolab/effect-firebase/firestore/DocumentPath"] === "~@visiolab/effect-firebase/firestore/DocumentPath" && Predicate.hasProperty(u, "path") && Predicate.isString(u.path);
+const Proto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "DocumentPath",
+			path: this.path
+		};
+	},
+	[Equal.symbol](that) {
+		return isDocumentPath(that) && this.path === that.path;
+	},
+	[Hash.symbol]() {
+		return Hash.string(this.path);
+	}
+};
+/**
+* Builds the value without checking `path`, for one that already addresses a
+* document, such as a reference's own.
+*
+* @internal
+*/
+const makeUnchecked = (path) => Object.assign(Object.create(Proto), { path });
+/** @internal */
+const make = (path) => addressesDocument(path) ? Option.some(makeUnchecked(path)) : Option.none();
+/** @internal */
+const makeUnsafe = (path) => {
+	if (!addressesDocument(path)) throw new Error(`Invalid Firestore document path "${path}": it must address a document`);
+	return makeUnchecked(path);
+};
+export { TypeId, isDocumentPath, make, makeUnchecked, makeUnsafe };

package/dist/firestore/internal/documentSnapshot.mjs

@@ -0,0 +1,63 @@
+import { toCodecFirestore } from "./firestoreValue.mjs";
+import { attach, extraToJson } from "./snapshotExtra.mjs";
+import { Effect, Inspectable, Predicate, Schema } from "effect";
+// src/firestore/internal/documentSnapshot.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/DocumentSnapshot";
+/** @internal */
+const isDocumentSnapshot = (u) => Predicate.hasProperty(u, TypeId);
+/** @internal */
+const isExisting = (self) => self._tag === "Existing";
+/** @internal */
+const isMissing = (self) => self._tag === "Missing";
+const ExistingProto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	_tag: "Existing",
+	toJSON() {
+		return {
+			_id: "DocumentSnapshot",
+			_tag: "Existing",
+			ref: this.ref.path,
+			raw: Inspectable.toJson(this.raw),
+			...extraToJson(this)
+		};
+	},
+	get data() {
+		const self = this;
+		return Effect.suspend(() => Schema.decodeUnknownEffect(toCodecFirestore(self.ref.collection.schema))(self.raw));
+	}
+};
+const MissingProto = {
+	...Inspectable.BaseProto,
+	[TypeId]: TypeId,
+	_tag: "Missing",
+	toJSON() {
+		return {
+			_id: "DocumentSnapshot",
+			_tag: "Missing",
+			ref: this.ref.path,
+			...extraToJson(this)
+		};
+	}
+};
+/** @internal */
+const existing = (ref, data, extra) => {
+	const self = Object.assign(Object.create(ExistingProto), {
+		ref,
+		id: ref.id,
+		raw: data
+	});
+	return attach(self, extra);
+};
+/** @internal */
+const missing = (ref, extra) => {
+	const self = Object.assign(Object.create(MissingProto), {
+		ref,
+		id: ref.id
+	});
+	return attach(self, extra);
+};
+/** @internal */
+const make = (ref, data, extra) => data === void 0 ? missing(ref, extra) : existing(ref, data, extra);
+export { TypeId, existing, isDocumentSnapshot, isExisting, isMissing, make, missing };

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

@@ -0,0 +1,11 @@
+import { ArrayRemove, ArrayUnion, DeleteField, Increment, ServerTimestamp } from "../FieldValue.mjs";
+/** @internal */
+export declare const isServerTimestamp: (u: unknown) => u is ServerTimestamp;
+/** @internal */
+export declare const isIncrement: (u: unknown) => u is Increment;
+/** @internal */
+export declare const isDeleteField: (u: unknown) => u is DeleteField;
+/** @internal */
+export declare const isArrayUnion: (u: unknown) => u is ArrayUnion<unknown>;
+/** @internal */
+export declare const isArrayRemove: (u: unknown) => u is ArrayRemove<unknown>;

package/dist/firestore/internal/fieldValue.mjs

@@ -0,0 +1,88 @@
+import { Equal, Hash, Inspectable, Predicate } from "effect";
+// src/firestore/internal/fieldValue.ts
+/** @internal */
+const ServerTimestampTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ServerTimestamp";
+const ServerTimestampProto = {
+	...Inspectable.BaseProto,
+	[ServerTimestampTypeId]: ServerTimestampTypeId,
+	toJSON() {
+		return { _id: "ServerTimestamp" };
+	}
+};
+/** @internal */
+const serverTimestamp = Object.create(ServerTimestampProto);
+/** @internal */
+const isServerTimestamp = (u) => Predicate.hasProperty(u, ServerTimestampTypeId);
+/** @internal */
+const IncrementTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/Increment";
+/** @internal */
+const isIncrement = (u) => Predicate.hasProperty(u, IncrementTypeId);
+const IncrementProto = {
+	...Inspectable.BaseProto,
+	[IncrementTypeId]: IncrementTypeId,
+	toJSON() {
+		return {
+			_id: "Increment",
+			by: this.by
+		};
+	},
+	[Equal.symbol](that) {
+		return isIncrement(that) && this.by === that.by;
+	},
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(IncrementTypeId), Hash.number(this.by));
+	}
+};
+/** @internal */
+const increment = (by) => {
+	if (!Number.isFinite(by)) throw new Error(`Invalid Firestore increment: by must be a finite number, got ${by}`);
+	return Object.assign(Object.create(IncrementProto), { by });
+};
+/** @internal */
+const decrement = (by) => increment(-by);
+/** @internal */
+const DeleteFieldTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/DeleteField";
+const DeleteFieldProto = {
+	...Inspectable.BaseProto,
+	[DeleteFieldTypeId]: DeleteFieldTypeId,
+	toJSON() {
+		return { _id: "DeleteField" };
+	}
+};
+/** @internal */
+const deleteField = Object.create(DeleteFieldProto);
+/** @internal */
+const isDeleteField = (u) => Predicate.hasProperty(u, DeleteFieldTypeId);
+/** @internal */
+const ArrayUnionTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ArrayUnion";
+const ArrayUnionProto = {
+	...Inspectable.BaseProto,
+	[ArrayUnionTypeId]: ArrayUnionTypeId,
+	toJSON() {
+		return {
+			_id: "ArrayUnion",
+			elements: this.elements.map((element) => Inspectable.toJson(element))
+		};
+	}
+};
+/** @internal */
+const isArrayUnion = (u) => Predicate.hasProperty(u, ArrayUnionTypeId);
+/** @internal */
+const arrayUnion = (...elements) => Object.assign(Object.create(ArrayUnionProto), { elements });
+/** @internal */
+const ArrayRemoveTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ArrayRemove";
+const ArrayRemoveProto = {
+	...Inspectable.BaseProto,
+	[ArrayRemoveTypeId]: ArrayRemoveTypeId,
+	toJSON() {
+		return {
+			_id: "ArrayRemove",
+			elements: this.elements.map((element) => Inspectable.toJson(element))
+		};
+	}
+};
+/** @internal */
+const isArrayRemove = (u) => Predicate.hasProperty(u, ArrayRemoveTypeId);
+/** @internal */
+const arrayRemove = (...elements) => Object.assign(Object.create(ArrayRemoveProto), { elements });
+export { ArrayRemoveTypeId, ArrayUnionTypeId, DeleteFieldTypeId, IncrementTypeId, ServerTimestampTypeId, arrayRemove, arrayUnion, decrement, deleteField, increment, isArrayRemove, isArrayUnion, isDeleteField, isIncrement, isServerTimestamp, serverTimestamp };

package/dist/firestore/internal/firestore.mjs

@@ -0,0 +1,145 @@
+import { checkDocument } from "./firestoreValueWalk.mjs";
+import { toCodecFirestore } from "./firestoreValue.mjs";
+import { existing, make as make$1 } from "./documentSnapshot.mjs";
+import { documentAt, isCollectionGroup } from "./collectionGroup.mjs";
+import { make as make$2 } from "./querySnapshot.mjs";
+import { Context, Effect, Result, Schema, Stream } from "effect";
+// src/firestore/internal/firestore.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/firestore/Firestore";
+/** @internal */
+const TransactionTypeId = "~@visiolab/effect-firebase/firestore/Firestore/Transaction";
+/** The last segment of a document's path: its id. */
+const idOf = (path) => path.slice(path.lastIndexOf("/") + 1);
+/**
+* What a hook is handed for `source`, and how each document it read is
+* addressed: in the collection read, by its id, or, for a group, matched by
+* its path to the collection of the group it lives in.
+*/
+const resolve = (source) => isCollectionGroup(source) ? {
+	selector: {
+		_tag: "CollectionGroup",
+		id: source.id
+	},
+	refOf: (path) => documentAt(source, path)
+} : {
+	selector: {
+		_tag: "Collection",
+		path: source.path
+	},
+	refOf: (path) => Result.succeed(source.doc(source.collection.id.make(idOf(path))))
+};
+/** A snapshot of the document at `ref`, as a hook read it, with its extra. */
+const documentSnapshotOf = (ref, read) => Result.map(checkDocument(ref.path, read.data), (data) => make$1(ref, data, read.extra));
+/**
+* A snapshot of the documents a hook read, each addressed by `refOf`, with the
+* extra of each and of the read as a whole.
+*/
+const querySnapshotOf = (refOf, read) => Result.map(Result.all(read.docs.map((doc) => Result.flatMap(refOf(doc.path), (ref) => Result.map(checkDocument(ref.path, doc.data), (data) => existing(ref, data, doc.extra))))), (docs) => make$2(docs, read.extra));
+/**
+* Turns what is written, in the shape `schema` takes, into Firestore Values,
+* through the codec derived from `schema`. Whatever services the schema
+* encodes through are left for the caller to provide.
+*/
+const encode = (schema, data) => Schema.encodeEffect(toCodecFirestore(schema))(data);
+/** A document, in its model's `create` shape. */
+const encodeCreate = (collection, data) => {
+	const schema = collection.schema.create;
+	return encode(schema, data);
+};
+/**
+* A patch, in its model's update shape for `mode`, which encodes to a map from
+* the field paths it writes at to what it writes there.
+*/
+const encodeUpdate = (collection, data, mode) => {
+	const schema = mode === "unchecked" ? collection.schema.updateUnchecked : collection.schema.update;
+	return encode(schema, data);
+};
+/**
+* The reads and writes a {@link Firestore.Firestore} and a transaction share,
+* made against `target`. Each runs in a span named after it, so traces read
+* the same whichever backend answered.
+*/
+const operations = (target) => {
+	const span = (name) => Effect.withSpan(`${target.name}.${name}`);
+	const getDocs = target.getDocs;
+	return {
+		getDoc: (ref, options) => Effect.flatMap(target.getDoc(ref.path, options), (read) => Effect.fromResult(documentSnapshotOf(ref, read))).pipe(span("getDoc")),
+		getDocs: getDocs === void 0 ? void 0 : (source, options) => {
+			const { selector, refOf } = resolve(source);
+			return Effect.flatMap(getDocs(selector, options), (read) => Effect.fromResult(querySnapshotOf(refOf, read))).pipe(span("getDocs"));
+		},
+		setDoc: (ref, data) => Effect.flatMap(encodeCreate(ref.collection, data), (encoded) => target.setDoc(ref.path, encoded)).pipe(span("setDoc")),
+		updateDoc: (ref, data, options) => Effect.flatMap(encodeUpdate(ref.collection, data, options?.mode), (encoded) => target.updateDoc(ref.path, encoded)).pipe(span("updateDoc"))
+	};
+};
+/**
+* The transaction a body reads and writes through, over the operations of one
+* attempt.
+*/
+const transactionOf = (transaction) => {
+	const readMany = transaction.getDocs;
+	const { getDoc, getDocs, setDoc, updateDoc } = operations({
+		name: "Firestore.Transaction",
+		getDoc: (path) => transaction.getDoc(path),
+		getDocs: readMany === void 0 ? void 0 : (selector) => readMany(selector),
+		setDoc: transaction.setDoc,
+		updateDoc: transaction.updateDoc
+	});
+	const portable = {
+		[TransactionTypeId]: TransactionTypeId,
+		getDoc,
+		setDoc,
+		updateDoc
+	};
+	return getDocs === void 0 ? portable : {
+		...portable,
+		getDocs
+	};
+};
+/**
+* The key a transaction body finds its {@link Firestore.Transaction} under is
+* handed in by the public module that defines it, so that this one only
+* imports it as a type and the two do not import each other.
+*
+* @internal
+*/
+const make = (options, Transaction) => {
+	const { getDoc, getDocs, setDoc, updateDoc } = operations({
+		name: "Firestore",
+		getDoc: options.getDoc,
+		getDocs: options.getDocs,
+		setDoc: options.setDoc,
+		updateDoc: options.updateDoc
+	});
+	const addDoc = (ref, data) => Effect.flatMap(encodeCreate(ref.collection, data), (encoded) => Effect.map(options.addDoc(ref.path, encoded), (id) => ref.doc(ref.collection.id.make(id)))).pipe(Effect.withSpan("Firestore.addDoc"));
+	const streamDoc = (ref, listenOptions) => Stream.mapEffect(options.streamDoc(ref.path, listenOptions), (read) => Effect.fromResult(documentSnapshotOf(ref, read))).pipe(Stream.withSpan("Firestore.streamDoc"));
+	const streamDocs = (source, listenOptions) => {
+		const { selector, refOf } = resolve(source);
+		return Stream.mapEffect(options.streamDocs(selector, listenOptions), (read) => Effect.fromResult(querySnapshotOf(refOf, read))).pipe(Stream.withSpan("Firestore.streamDocs"));
+	};
+	const service = {
+		getDoc,
+		getDocs,
+		setDoc,
+		updateDoc,
+		addDoc,
+		streamDoc,
+		streamDocs,
+		runTransaction: Effect.fn("Firestore.runTransaction")(function* (effect, transactionOptions) {
+			const context = yield* Effect.context();
+			const offer = options.runTransaction.context;
+			const maxAttempts = transactionOptions?.maxAttempts;
+			return yield* options.runTransaction.run((operations) => {
+				const transaction = transactionOf(operations);
+				const withTransaction = Context.add(context, Transaction, transaction);
+				return Effect.provideContext(effect, offer === void 0 ? withTransaction : Context.merge(withTransaction, offer(transaction)));
+			}, maxAttempts === void 0 ? {} : { maxAttempts });
+		})
+	};
+	return {
+		[TypeId]: TypeId,
+		...service
+	};
+};
+export { TransactionTypeId, TypeId, make };

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

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+declare const FirestoreError_base: Schema.Class<FirestoreError, Schema.TaggedStruct<"FirestoreError", {
+  readonly message: Schema.String;
+  /**
+   * The code the SDK reported, where it reported one it can be named by.
+   *
+   * The client SDK names every failure, such as `permission-denied`. The Admin
+   * SDK answers for Firestore over gRPC, which numbers its statuses rather than
+   * naming them, so there this is often absent even where something went wrong
+   * at the database.
+   */
+  readonly code: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** @internal */
+export declare class FirestoreError extends FirestoreError_base {}
+declare const UndefinedCollectionError_base: Schema.Class<UndefinedCollectionError, Schema.TaggedStruct<"UndefinedCollectionError", {
+  /** The full path of the document no collection of the group defines. */
+  readonly path: Schema.String;
+  /** The collection id of the group that was read. */
+  readonly collectionId: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** @internal */
+export declare class UndefinedCollectionError extends UndefinedCollectionError_base {}
+export {};

package/dist/firestore/internal/firestoreError.mjs

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+// src/firestore/internal/firestoreError.ts
+/**
+* The errors of the Firestore module, defined apart from it so that the
+* modules it builds on can raise them without importing it back: the public
+* module imports its implementation, and an import cycle through it would
+* leave these unset while a bundle evaluates.
+*/
+/** @internal */
+var FirestoreError = class extends Schema.TaggedError()("FirestoreError", {
+	message: Schema.String,
+	/**
+	* The code the SDK reported, where it reported one it can be named by.
+	*
+	* The client SDK names every failure, such as `permission-denied`. The Admin
+	* SDK answers for Firestore over gRPC, which numbers its statuses rather than
+	* naming them, so there this is often absent even where something went wrong
+	* at the database.
+	*/
+	code: Schema.optional(Schema.String),
+	cause: Schema.optional(Schema.Defect())
+}) {};
+/** @internal */
+var UndefinedCollectionError = class extends Schema.TaggedError()("UndefinedCollectionError", {
+	/** The full path of the document no collection of the group defines. */
+	path: Schema.String,
+	/** The collection id of the group that was read. */
+	collectionId: Schema.String
+}) {};
+export { FirestoreError, UndefinedCollectionError };