@visiolab/effect-firebase-client 0.0.0-stage → 0.3.1

package/dist/firestore/ClientQuerySnapshot.d.mts

@@ -0,0 +1,52 @@
+import { Existing as Existing$1, SnapshotMetadata } from "./ClientDocumentSnapshot.mjs";
+import * as QuerySnapshot from "@visiolab/effect-firebase/firestore/QuerySnapshot";
+import * as Collection from "@visiolab/effect-firebase/firestore/Collection";
+declare namespace ClientQuerySnapshot_d_exports {
+  export { ClientQuerySnapshot, Existing, make };
+}
+/**
+ * A client snapshot of a document that was there when it was read, of
+ * whichever of the collections in `C` it is in.
+ *
+ * @see {@link QuerySnapshot.Existing} for the portable type
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type Existing<C extends Collection.Any> = C extends Collection.Any ? Existing$1<C> : never;
+/**
+ * The documents in `C` a read of many found, with the
+ * {@link ClientDocumentSnapshot.SnapshotMetadata} of that read.
+ *
+ * Each of its `docs` carries its own metadata too, and is of the one
+ * collection in `C` it is in.
+ *
+ * @see {@link QuerySnapshot.QuerySnapshot} for the portable snapshot it extends
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface ClientQuerySnapshot<C extends Collection.Any> extends QuerySnapshot.QuerySnapshot<C, {
+  readonly metadata: SnapshotMetadata;
+}> {
+  /** Where the read as a whole came from. */
+  readonly metadata: SnapshotMetadata;
+}
+/**
+ * Builds a snapshot of the documents a read of many found, with the
+ * `snapshot.metadata` the client SDK reported for the read.
+ *
+ * **When to use**
+ *
+ * Use to turn a query snapshot read through the client SDK itself into this
+ * library's. Build each document with {@link ClientDocumentSnapshot.existing}.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <C extends Collection.Any>(docs: ReadonlyArray<Existing$1<C>>, metadata: SnapshotMetadata) => ClientQuerySnapshot<C>;
+export { ClientQuerySnapshot_d_exports };
+//# sourceMappingURL=ClientQuerySnapshot.d.mts.map

package/dist/firestore/ClientQuerySnapshot.mjs

@@ -0,0 +1,58 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { extraOf } from "./internal/snapshotMetadata.mjs";
+import * as QuerySnapshot from "@visiolab/effect-firebase/firestore/QuerySnapshot";
+// src/firestore/ClientQuerySnapshot.ts
+/**
+* What a read of many documents through
+* {@link ClientFirestore.ClientFirestore} returns: a portable
+* {@link QuerySnapshot.QuerySnapshot} that also carries the
+* {@link ClientDocumentSnapshot.SnapshotMetadata} the client SDK reported for
+* the read as a whole, and whose documents carry their own.
+*
+* The snapshot's own metadata says where a read that found nothing came from,
+* since there is no document to ask.
+*
+* @example Telling an empty cache from an empty collection
+* ```ts
+* import { Effect, Schema } from "effect";
+* import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+* import { ClientFirestore } from "@visiolab/effect-firebase-client/firestore";
+*
+* class User extends FirestoreModel.Class<User>("User")({
+*   name: Schema.String,
+* }) {}
+*
+* const Users = Collection.make("users", User);
+*
+* const program = Effect.gen(function* () {
+*   const firestore = yield* ClientFirestore.ClientFirestore;
+*   const snapshot = yield* firestore.getDocs(Users.collection());
+*   if (snapshot.docs.length === 0 && snapshot.metadata.fromCache) {
+*     // Nothing in the local cache, which says nothing of the server.
+*   }
+* });
+* ```
+*
+* @see {@link ClientDocumentSnapshot} for what a read of one document returns
+*
+* @stability unstable
+* @since 0.1.0
+*/
+var ClientQuerySnapshot_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/**
+* Builds a snapshot of the documents a read of many found, with the
+* `snapshot.metadata` the client SDK reported for the read.
+*
+* **When to use**
+*
+* Use to turn a query snapshot read through the client SDK itself into this
+* library's. Build each document with {@link ClientDocumentSnapshot.existing}.
+*
+* @stability unstable
+* @category constructors
+* @since 0.1.0
+*/
+const make = (docs, metadata) => QuerySnapshot.make(docs, extraOf(metadata));
+export { ClientQuerySnapshot_exports, make };
+
+//# sourceMappingURL=ClientQuerySnapshot.mjs.map

package/dist/firestore/ClientQuerySnapshot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientQuerySnapshot.mjs","names":["snapshotMetadata.extraOf"],"sources":["../../src/firestore/ClientQuerySnapshot.ts"],"sourcesContent":["/**\n * What a read of many documents through\n * {@link ClientFirestore.ClientFirestore} returns: a portable\n * {@link QuerySnapshot.QuerySnapshot} that also carries the\n * {@link ClientDocumentSnapshot.SnapshotMetadata} the client SDK reported for\n * the read as a whole, and whose documents carry their own.\n *\n * The snapshot's own metadata says where a read that found nothing came from,\n * since there is no document to ask.\n *\n * @example Telling an empty cache from an empty collection\n * ```ts\n * import { Effect, Schema } from \"effect\";\n * import { Collection, FirestoreModel } from \"@visiolab/effect-firebase/firestore\";\n * import { ClientFirestore } from \"@visiolab/effect-firebase-client/firestore\";\n *\n * class User extends FirestoreModel.Class<User>(\"User\")({\n *   name: Schema.String,\n * }) {}\n *\n * const Users = Collection.make(\"users\", User);\n *\n * const program = Effect.gen(function* () {\n *   const firestore = yield* ClientFirestore.ClientFirestore;\n *   const snapshot = yield* firestore.getDocs(Users.collection());\n *   if (snapshot.docs.length === 0 && snapshot.metadata.fromCache) {\n *     // Nothing in the local cache, which says nothing of the server.\n *   }\n * });\n * ```\n *\n * @see {@link ClientDocumentSnapshot} for what a read of one document returns\n *\n * @stability unstable\n * @since 0.1.0\n */\nimport * as QuerySnapshot from \"@visiolab/effect-firebase/firestore/QuerySnapshot\";\nimport type * as Collection from \"@visiolab/effect-firebase/firestore/Collection\";\nimport type * as ClientDocumentSnapshot from \"./ClientDocumentSnapshot.ts\";\nimport * as snapshotMetadata from \"./internal/snapshotMetadata.ts\";\n\n/**\n * A client snapshot of a document that was there when it was read, of\n * whichever of the collections in `C` it is in.\n *\n * @see {@link QuerySnapshot.Existing} for the portable type\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport type Existing<C extends Collection.Any> = C extends Collection.Any\n  ? ClientDocumentSnapshot.Existing<C>\n  : never;\n\n/**\n * The documents in `C` a read of many found, with the\n * {@link ClientDocumentSnapshot.SnapshotMetadata} of that read.\n *\n * Each of its `docs` carries its own metadata too, and is of the one\n * collection in `C` it is in.\n *\n * @see {@link QuerySnapshot.QuerySnapshot} for the portable snapshot it extends\n *\n * @stability unstable\n * @category models\n * @since 0.1.0\n */\nexport interface ClientQuerySnapshot<C extends Collection.Any> extends QuerySnapshot.QuerySnapshot<\n  C,\n  { readonly metadata: ClientDocumentSnapshot.SnapshotMetadata }\n> {\n  /** Where the read as a whole came from. */\n  readonly metadata: ClientDocumentSnapshot.SnapshotMetadata;\n}\n\n/**\n * Builds a snapshot of the documents a read of many found, with the\n * `snapshot.metadata` the client SDK reported for the read.\n *\n * **When to use**\n *\n * Use to turn a query snapshot read through the client SDK itself into this\n * library's. Build each document with {@link ClientDocumentSnapshot.existing}.\n *\n * @stability unstable\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <C extends Collection.Any>(\n  docs: ReadonlyArray<ClientDocumentSnapshot.Existing<C>>,\n  metadata: ClientDocumentSnapshot.SnapshotMetadata,\n): ClientQuerySnapshot<C> => QuerySnapshot.make(docs, snapshotMetadata.extraOf(metadata));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,MAAa,QACX,MACA,aAC2B,cAAc,KAAK,MAAMA,QAAyB,QAAQ,CAAC"}

package/dist/firestore/index.d.mts

@@ -0,0 +1,5 @@
+import { ClientDocumentSnapshot_d_exports } from "./ClientDocumentSnapshot.mjs";
+import { ClientFirestore_d_exports } from "./ClientFirestore.mjs";
+import { ClientFirestoreValue_d_exports } from "./ClientFirestoreValue.mjs";
+import { ClientQuerySnapshot_d_exports } from "./ClientQuerySnapshot.mjs";
+export { ClientDocumentSnapshot_d_exports as ClientDocumentSnapshot, ClientFirestore_d_exports as ClientFirestore, ClientFirestoreValue_d_exports as ClientFirestoreValue, ClientQuerySnapshot_d_exports as ClientQuerySnapshot };

package/dist/firestore/index.mjs

@@ -0,0 +1,5 @@
+import { ClientDocumentSnapshot_exports } from "./ClientDocumentSnapshot.mjs";
+import { ClientFirestore_exports } from "./ClientFirestore.mjs";
+import { ClientFirestoreValue_exports } from "./ClientFirestoreValue.mjs";
+import { ClientQuerySnapshot_exports } from "./ClientQuerySnapshot.mjs";
+export { ClientDocumentSnapshot_exports as ClientDocumentSnapshot, ClientFirestore_exports as ClientFirestore, ClientFirestoreValue_exports as ClientFirestoreValue, ClientQuerySnapshot_exports as ClientQuerySnapshot };

package/dist/firestore/internal/firestore.mjs

@@ -0,0 +1,158 @@
+import { App } from "../../app/App.mjs";
+import { extraOf } from "./snapshotMetadata.mjs";
+import { readDocument, toClient } from "./firestoreValue.mjs";
+import { Effect, Result } from "effect";
+import { FirebaseError } from "firebase/app";
+import * as Firestore$2 from "@visiolab/effect-firebase/firestore/Firestore";
+import * as Client from "firebase/firestore";
+// src/firestore/internal/firestore.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase-client/firestore/ClientFirestore";
+/**
+* Opens the database the options name.
+*
+* Settings can only be handed over through `initializeFirestore`, which refuses
+* a database already opened, so they are only passed along when there are
+* some: asking for the default database twice keeps working, and asking for it
+* twice with settings is the mistake it reports.
+*
+* The emulator is connected after, which the SDK takes as often as it is asked
+* for the same one, but only before the database is first used.
+*/
+const open = (app, options) => {
+	const databaseId = options?.databaseId;
+	const firestore = options?.localCache === void 0 ? databaseId === void 0 ? Client.getFirestore(app) : Client.getFirestore(app, databaseId) : Client.initializeFirestore(app, { localCache: options.localCache }, databaseId);
+	if (options?.emulator !== void 0) Client.connectFirestoreEmulator(firestore, options.emulator.host, options.emulator.port);
+	return firestore;
+};
+/**
+* Opens the database the options name on the {@link App.App} in context.
+*
+* The SDK memoizes a database on the app itself, and deleting the app
+* terminates it, so there is nothing to release here.
+*
+* @internal
+*/
+const openDatabase = Effect.fnUntraced(function* (options) {
+	const app = yield* App;
+	return open(app, options);
+});
+const firestoreError = (message) => (cause) => new Firestore$2.FirestoreError({
+	message,
+	code: cause instanceof FirebaseError ? cause.code : void 0,
+	cause
+});
+/** Runs one call to the SDK, turning what it throws or rejects with into a `FirestoreError`. */
+const call = (message, f) => Effect.tryPromise({
+	try: () => Promise.resolve(f()),
+	catch: firestoreError(message)
+});
+/**
+* Reads a document's data as Firestore Values, with the server timestamps it
+* is still waiting on estimated, rather than left `null` where a timestamp is
+* expected.
+*
+* A document holding a value outside the Firestore Value union, such as a
+* vector, fails to read: it could only ever be decoded as an untyped object.
+* `data()` hands back `undefined` for a document that is not there, which is
+* kept as it is.
+*/
+const dataOf = (path, snapshot) => readDocument(path, snapshot.data({ serverTimestamps: "estimate" }));
+/** A read of one document, with the metadata the SDK reported for it. */
+const documentReadOf = (snapshot) => Result.map(dataOf(snapshot.ref.path, snapshot), (data) => ({
+	data,
+	extra: extraOf(snapshot.metadata)
+}));
+/** A read of many documents, each and as a whole with the metadata the SDK reported. */
+const queryReadOf = (query) => Result.map(Result.all(query.docs.map((snapshot) => Result.map(dataOf(snapshot.ref.path, snapshot), (data) => ({
+	path: snapshot.ref.path,
+	data,
+	extra: extraOf(snapshot.metadata)
+})))), (docs) => ({
+	docs,
+	extra: extraOf(query.metadata)
+}));
+/** The client SDK query `selector` names, and what it is called in a failure. */
+const queryOf = (firestore, selector) => selector._tag === "CollectionGroup" ? {
+	query: Client.collectionGroup(firestore, selector.id),
+	name: `the collection group "${selector.id}"`
+} : {
+	query: Client.collection(firestore, selector.path),
+	name: `the collection "${selector.path}"`
+};
+const reads = {
+	default: {
+		getDoc: Client.getDoc,
+		getDocs: Client.getDocs
+	},
+	server: {
+		getDoc: Client.getDocFromServer,
+		getDocs: Client.getDocsFromServer
+	},
+	cache: {
+		getDoc: Client.getDocFromCache,
+		getDocs: Client.getDocsFromCache
+	}
+};
+/** The SDK's reads from where `options` names, `"default"` where it names none. */
+const readsFrom = (options) => reads[options?.source ?? "default"];
+/**
+* The SDK's listen options for `options`, leaving out what is not given rather
+* than handing the SDK an `undefined` in its place.
+*/
+const snapshotListenOptions = (options) => ({
+	...options?.includeMetadataChanges === void 0 ? {} : { includeMetadataChanges: options.includeMetadataChanges },
+	...options?.source === void 0 ? {} : { source: options.source }
+});
+/**
+* The service over a database already opened.
+*
+* @internal
+*/
+const fromDatabase = (firestore) => {
+	const docOf = (path) => Client.doc(firestore, path);
+	const toClient$1 = (data) => toClient(data, firestore);
+	const made = Firestore$2.make({
+		getDoc: (path, options) => Effect.flatMap(call(`Failed to read the document "${path}"`, () => readsFrom(options).getDoc(docOf(path))), (snapshot) => Effect.fromResult(documentReadOf(snapshot))),
+		getDocs: (selector, options) => {
+			const { query, name } = queryOf(firestore, selector);
+			return Effect.flatMap(call(`Failed to read ${name}`, () => readsFrom(options).getDocs(query)), (snapshot) => Effect.fromResult(queryReadOf(snapshot)));
+		},
+		setDoc: (path, data) => call(`Failed to write the document "${path}"`, () => Client.setDoc(docOf(path), toClient$1(data))),
+		updateDoc: (path, data) => call(`Failed to update the document "${path}"`, () => Client.updateDoc(docOf(path), toClient$1(data))),
+		addDoc: (path, data) => Effect.map(call(`Failed to add a document to "${path}"`, () => Client.addDoc(Client.collection(firestore, path), toClient$1(data))), (added) => added.id),
+		streamDoc: (path, options) => Firestore$2.streamFromListener({
+			subscribe: (onNext, onError) => Client.onSnapshot(docOf(path), snapshotListenOptions(options), onNext, onError),
+			onError: firestoreError(`Failed to listen to the document "${path}"`),
+			map: documentReadOf
+		}),
+		streamDocs: (selector, options) => {
+			const { query, name } = queryOf(firestore, selector);
+			return Firestore$2.streamFromListener({
+				subscribe: (onNext, onError) => Client.onSnapshot(query, snapshotListenOptions(options), onNext, onError),
+				onError: firestoreError(`Failed to listen to ${name}`),
+				map: queryReadOf
+			});
+		},
+		runTransaction: Firestore$2.transactionFromCallback({
+			run: (callback, options) => Client.runTransaction(firestore, callback, options),
+			operations: (tx) => ({
+				getDoc: (path) => Effect.flatMap(call(`Failed to read the document "${path}"`, () => tx.get(docOf(path))), (snapshot) => Effect.fromResult(Result.map(dataOf(path, snapshot), (data) => ({ data })))),
+				setDoc: (path, data) => call(`Failed to write the document "${path}"`, () => {
+					tx.set(docOf(path), toClient$1(data));
+				}),
+				updateDoc: (path, data) => call(`Failed to update the document "${path}"`, () => {
+					tx.update(docOf(path), toClient$1(data));
+				})
+			}),
+			onError: firestoreError("Failed to run a transaction")
+		})
+	});
+	return Object.assign(made, {
+		[TypeId]: TypeId,
+		instance: firestore
+	});
+};
+export { TypeId, fromDatabase, openDatabase };
+
+//# sourceMappingURL=firestore.mjs.map

package/dist/firestore/internal/firestore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.mjs","names":["App.App","Firestore","firestoreValue.readDocument","snapshotMetadata.extraOf","toClient","firestoreValue.toClient"],"sources":["../../../src/firestore/internal/firestore.ts"],"sourcesContent":["import { Effect, Result } from \"effect\";\nimport * as Firestore from \"@visiolab/effect-firebase/firestore/Firestore\";\nimport { FirebaseError } from \"firebase/app\";\nimport * as Client from \"firebase/firestore\";\nimport * as App from \"../../app/App.ts\";\nimport type * as ClientFirestore from \"../ClientFirestore.ts\";\nimport * as firestoreValue from \"./firestoreValue.ts\";\nimport * as snapshotMetadata from \"./snapshotMetadata.ts\";\n\n/** @internal */\nexport const TypeId = \"~@visiolab/effect-firebase-client/firestore/ClientFirestore\";\n\n/**\n * Opens the database the options name.\n *\n * Settings can only be handed over through `initializeFirestore`, which refuses\n * a database already opened, so they are only passed along when there are\n * some: asking for the default database twice keeps working, and asking for it\n * twice with settings is the mistake it reports.\n *\n * The emulator is connected after, which the SDK takes as often as it is asked\n * for the same one, but only before the database is first used.\n */\nconst open = (app: App.App, options: ClientFirestore.Options | undefined): Client.Firestore => {\n  const databaseId = options?.databaseId;\n  const firestore =\n    options?.localCache === undefined\n      ? databaseId === undefined\n        ? Client.getFirestore(app)\n        : Client.getFirestore(app, databaseId)\n      : Client.initializeFirestore(app, { localCache: options.localCache }, databaseId);\n  if (options?.emulator !== undefined) {\n    Client.connectFirestoreEmulator(firestore, options.emulator.host, options.emulator.port);\n  }\n  return firestore;\n};\n\n/**\n * Opens the database the options name on the {@link App.App} in context.\n *\n * The SDK memoizes a database on the app itself, and deleting the app\n * terminates it, so there is nothing to release here.\n *\n * @internal\n */\nexport const openDatabase = Effect.fnUntraced(function* (options?: ClientFirestore.Options) {\n  const app = yield* App.App;\n  return open(app, options);\n});\n\nconst firestoreError = (message: string) => (cause: unknown) =>\n  new Firestore.FirestoreError({\n    message,\n    // The client SDK names every failure it reports, such as\n    // `permission-denied`, whether it raised it itself or the database did.\n    code: cause instanceof FirebaseError ? cause.code : undefined,\n    cause,\n  });\n\n/** Runs one call to the SDK, turning what it throws or rejects with into a `FirestoreError`. */\nconst call = <A>(\n  message: string,\n  f: () => PromiseLike<A> | A,\n): Effect.Effect<A, Firestore.FirestoreError> =>\n  Effect.tryPromise({\n    try: () => Promise.resolve(f()),\n    catch: firestoreError(message),\n  });\n\n/**\n * Reads a document's data as Firestore Values, with the server timestamps it\n * is still waiting on estimated, rather than left `null` where a timestamp is\n * expected.\n *\n * A document holding a value outside the Firestore Value union, such as a\n * vector, fails to read: it could only ever be decoded as an untyped object.\n * `data()` hands back `undefined` for a document that is not there, which is\n * kept as it is.\n */\nconst dataOf = (\n  path: string,\n  snapshot: Client.DocumentSnapshot,\n): Result.Result<Firestore.DocumentData | undefined, Firestore.FirestoreError> =>\n  firestoreValue.readDocument(\n    path,\n    snapshot.data({ serverTimestamps: \"estimate\" }),\n  ) as Result.Result<Firestore.DocumentData | undefined, Firestore.FirestoreError>;\n\n/** What the client knows about a read beyond the portable snapshot. */\ntype Extra = ReturnType<typeof snapshotMetadata.extraOf>;\n\n/** A read of one document, with the metadata the SDK reported for it. */\nconst documentReadOf = (\n  snapshot: Client.DocumentSnapshot,\n): Result.Result<Firestore.DocumentRead<Extra>, Firestore.FirestoreError> =>\n  Result.map(dataOf(snapshot.ref.path, snapshot), (data) => ({\n    data,\n    extra: snapshotMetadata.extraOf(snapshot.metadata),\n  }));\n\n/** A read of many documents, each and as a whole with the metadata the SDK reported. */\nconst queryReadOf = (\n  query: Client.QuerySnapshot,\n): Result.Result<Firestore.QueryRead<Extra>, Firestore.FirestoreError> =>\n  Result.map(\n    Result.all(\n      query.docs.map((snapshot) =>\n        Result.map(dataOf(snapshot.ref.path, snapshot), (data) => ({\n          path: snapshot.ref.path,\n          // A query only hands back documents that are there.\n          data: data as Firestore.DocumentData,\n          extra: snapshotMetadata.extraOf(snapshot.metadata),\n        })),\n      ),\n    ),\n    (docs) => ({ docs, extra: snapshotMetadata.extraOf(query.metadata) }),\n  );\n\n/** The client SDK query `selector` names, and what it is called in a failure. */\nconst queryOf = (\n  firestore: Client.Firestore,\n  selector: Firestore.CollectionSelector,\n): { readonly query: Client.Query; readonly name: string } =>\n  selector._tag === \"CollectionGroup\"\n    ? {\n        query: Client.collectionGroup(firestore, selector.id),\n        name: `the collection group \"${selector.id}\"`,\n      }\n    : {\n        query: Client.collection(firestore, selector.path),\n        name: `the collection \"${selector.path}\"`,\n      };\n\n/** The SDK's own reads, for one {@link ClientFirestore.ReadSource}. */\ninterface Reads {\n  readonly getDoc: (ref: Client.DocumentReference) => Promise<Client.DocumentSnapshot>;\n  readonly getDocs: (query: Client.Query) => Promise<Client.QuerySnapshot>;\n}\n\nconst reads: Record<ClientFirestore.ReadSource, Reads> = {\n  default: { getDoc: Client.getDoc, getDocs: Client.getDocs },\n  server: { getDoc: Client.getDocFromServer, getDocs: Client.getDocsFromServer },\n  cache: { getDoc: Client.getDocFromCache, getDocs: Client.getDocsFromCache },\n};\n\n/** The SDK's reads from where `options` names, `\"default\"` where it names none. */\nconst readsFrom = (options: ClientFirestore.ReadOptions | undefined): Reads =>\n  reads[options?.source ?? \"default\"];\n\n/**\n * The SDK's listen options for `options`, leaving out what is not given rather\n * than handing the SDK an `undefined` in its place.\n */\nconst snapshotListenOptions = (\n  options: ClientFirestore.ListenOptions | undefined,\n): Client.SnapshotListenOptions => ({\n  ...(options?.includeMetadataChanges === undefined\n    ? {}\n    : { includeMetadataChanges: options.includeMetadataChanges }),\n  ...(options?.source === undefined ? {} : { source: options.source }),\n});\n\n/**\n * The service over a database already opened.\n *\n * @internal\n */\nexport const fromDatabase = (\n  firestore: Client.Firestore,\n): ClientFirestore.ClientFirestore & Firestore.Firestore => {\n  const docOf = (path: string) => Client.doc(firestore, path);\n  const toClient = (data: Firestore.DocumentData) =>\n    firestoreValue.toClient(data, firestore) as Client.DocumentData;\n\n  const made = Firestore.make({\n    getDoc: (path, options: ClientFirestore.ReadOptions | undefined) =>\n      Effect.flatMap(\n        call(`Failed to read the document \"${path}\"`, () => readsFrom(options).getDoc(docOf(path))),\n        (snapshot) => Effect.fromResult(documentReadOf(snapshot)),\n      ),\n\n    getDocs: (selector, options: ClientFirestore.ReadOptions | undefined) => {\n      const { query, name } = queryOf(firestore, selector);\n      return Effect.flatMap(\n        call(`Failed to read ${name}`, () => readsFrom(options).getDocs(query)),\n        (snapshot) => Effect.fromResult(queryReadOf(snapshot)),\n      );\n    },\n\n    setDoc: (path, data) =>\n      call(`Failed to write the document \"${path}\"`, () =>\n        Client.setDoc(docOf(path), toClient(data)),\n      ),\n\n    updateDoc: (path, data) =>\n      call(`Failed to update the document \"${path}\"`, () =>\n        Client.updateDoc(docOf(path), toClient(data)),\n      ),\n\n    addDoc: (path, data) =>\n      Effect.map(\n        call(`Failed to add a document to \"${path}\"`, () =>\n          Client.addDoc(Client.collection(firestore, path), toClient(data)),\n        ),\n        (added) => added.id,\n      ),\n\n    // The client SDK hands a listener the documents as this client last wrote\n    // them, before the database has taken the writes, so each write is seen\n    // straight away rather than once it is acknowledged.\n    streamDoc: (path, options: ClientFirestore.ListenOptions | undefined) =>\n      Firestore.streamFromListener({\n        subscribe: (onNext, onError) =>\n          Client.onSnapshot(docOf(path), snapshotListenOptions(options), onNext, onError),\n        onError: firestoreError(`Failed to listen to the document \"${path}\"`),\n        map: documentReadOf,\n      }),\n\n    streamDocs: (selector, options: ClientFirestore.ListenOptions | undefined) => {\n      const { query, name } = queryOf(firestore, selector);\n      return Firestore.streamFromListener({\n        subscribe: (onNext, onError) =>\n          Client.onSnapshot(query, snapshotListenOptions(options), onNext, onError),\n        onError: firestoreError(`Failed to listen to ${name}`),\n        map: queryReadOf,\n      });\n    },\n\n    runTransaction: Firestore.transactionFromCallback({\n      run: (callback, options) => Client.runTransaction(firestore, callback, options),\n      operations: (tx: Client.Transaction) => ({\n        // A transaction reads from the server alone and never holds writes of\n        // its own that are pending, so its metadata says nothing and is left\n        // out: what it hands back is the portable snapshot.\n        getDoc: (path) =>\n          Effect.flatMap(\n            call(`Failed to read the document \"${path}\"`, () => tx.get(docOf(path))),\n            (snapshot) =>\n              Effect.fromResult(Result.map(dataOf(path, snapshot), (data) => ({ data }))),\n          ),\n        // Writes into a transaction are queued rather than sent, so these return\n        // straight away - or throw, where the transaction refuses them.\n        setDoc: (path, data) =>\n          call(`Failed to write the document \"${path}\"`, () => {\n            tx.set(docOf(path), toClient(data));\n          }),\n        updateDoc: (path, data) =>\n          call(`Failed to update the document \"${path}\"`, () => {\n            tx.update(docOf(path), toClient(data));\n          }),\n      }),\n      onError: firestoreError(\"Failed to run a transaction\"),\n    }),\n  });\n\n  // `make` infers the read source and listen options its hooks are handed and\n  // the metadata they read with each snapshot, so the client's interface is\n  // checked against what it built here.\n  const service: ClientFirestore.ClientFirestore & Firestore.Firestore = Object.assign(made, {\n    [TypeId]: TypeId as typeof TypeId,\n    instance: firestore,\n  });\n  return service;\n};\n"],"mappings":"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"}

package/dist/firestore/internal/firestoreValue.mjs

@@ -0,0 +1,43 @@
+import * as Client from "firebase/firestore";
+import * as DocumentPath from "@visiolab/effect-firebase/firestore/DocumentPath";
+import * as FirestoreValue$1 from "@visiolab/effect-firebase/firestore/FirestoreValue";
+import * as GeoPoint from "@visiolab/effect-firebase/firestore/GeoPoint";
+import * as Timestamp from "@visiolab/effect-firebase/firestore/Timestamp";
+// src/firestore/internal/firestoreValue.ts
+/** How the client SDK writes each kind of Firestore Value into `firestore`. */
+const writer = (firestore) => ({
+	bytes: (bytes) => Client.Bytes.fromUint8Array(bytes),
+	timestamp: (ts) => new Client.Timestamp(ts.seconds, ts.nanoseconds),
+	geoPoint: (point) => new Client.GeoPoint(point.latitude, point.longitude),
+	documentPath: (ref) => Client.doc(firestore, ref.path),
+	serverTimestamp: () => Client.serverTimestamp(),
+	increment: (increment) => Client.increment(increment.by),
+	deleteField: () => Client.deleteField(),
+	arrayUnion: (union, walk) => Client.arrayUnion(...union.elements.map(walk)),
+	arrayRemove: (remove, walk) => Client.arrayRemove(...remove.elements.map(walk))
+});
+/** @internal */
+const toClient = (value, firestore) => FirestoreValue$1.toSdk(value, writer(firestore));
+/**
+* How the client SDK's own values read back as Firestore Values. Its
+* sentinels are not read back: a read never hands one back, and the names it
+* keeps them by are internal to it.
+*/
+const reader = (u) => {
+	if (u instanceof Client.Timestamp) return Timestamp.makeUnsafe(u.seconds, u.nanoseconds);
+	if (u instanceof Client.GeoPoint) return GeoPoint.makeUnsafe(u.latitude, u.longitude);
+	if (u instanceof Client.DocumentReference) return DocumentPath.makeUnsafe(u.path);
+	if (u instanceof Client.Bytes) return u.toUint8Array();
+};
+/** @internal */
+const fromClient = (value) => FirestoreValue$1.fromSdk(value, reader);
+/**
+* What the client SDK read for the document at `path`, as Firestore Values,
+* or `undefined` for a document that is not there.
+*
+* @internal
+*/
+const readDocument = (path, data) => FirestoreValue$1.readDocument(path, data, reader);
+export { fromClient, readDocument, toClient };
+
+//# sourceMappingURL=firestoreValue.mjs.map

package/dist/firestore/internal/firestoreValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestoreValue.mjs","names":["FirestoreValue"],"sources":["../../../src/firestore/internal/firestoreValue.ts"],"sourcesContent":["import type { Result } from \"effect\";\nimport * as DocumentPath from \"@visiolab/effect-firebase/firestore/DocumentPath\";\nimport type { FirestoreError } from \"@visiolab/effect-firebase/firestore/Firestore\";\nimport * as FirestoreValue from \"@visiolab/effect-firebase/firestore/FirestoreValue\";\nimport * as GeoPoint from \"@visiolab/effect-firebase/firestore/GeoPoint\";\nimport * as Timestamp from \"@visiolab/effect-firebase/firestore/Timestamp\";\nimport * as Client from \"firebase/firestore\";\n\n/** How the client SDK writes each kind of Firestore Value into `firestore`. */\nconst writer = (firestore: Client.Firestore): FirestoreValue.Writer => ({\n  // The client SDK refuses a raw `Uint8Array`, as a custom object.\n  bytes: (bytes) => Client.Bytes.fromUint8Array(bytes),\n  timestamp: (ts) => new Client.Timestamp(ts.seconds, ts.nanoseconds),\n  geoPoint: (point) => new Client.GeoPoint(point.latitude, point.longitude),\n  documentPath: (ref) => Client.doc(firestore, ref.path),\n  serverTimestamp: () => Client.serverTimestamp(),\n  increment: (increment) => Client.increment(increment.by),\n  deleteField: () => Client.deleteField(),\n  arrayUnion: (union, walk) => Client.arrayUnion(...union.elements.map(walk)),\n  arrayRemove: (remove, walk) => Client.arrayRemove(...remove.elements.map(walk)),\n});\n\n/** @internal */\nexport const toClient = (\n  value: FirestoreValue.FirestoreValue,\n  firestore: Client.Firestore,\n): unknown => FirestoreValue.toSdk(value, writer(firestore));\n\n/**\n * How the client SDK's own values read back as Firestore Values. Its\n * sentinels are not read back: a read never hands one back, and the names it\n * keeps them by are internal to it.\n */\nconst reader: FirestoreValue.Reader = (u) => {\n  if (u instanceof Client.Timestamp) return Timestamp.makeUnsafe(u.seconds, u.nanoseconds);\n  if (u instanceof Client.GeoPoint) return GeoPoint.makeUnsafe(u.latitude, u.longitude);\n  if (u instanceof Client.DocumentReference) return DocumentPath.makeUnsafe(u.path);\n  if (u instanceof Client.Bytes) return u.toUint8Array();\n  return undefined;\n};\n\n/** @internal */\nexport const fromClient = (\n  value: unknown,\n): Result.Result<FirestoreValue.FirestoreValue, FirestoreError> =>\n  FirestoreValue.fromSdk(value, reader);\n\n/**\n * What the client SDK read for the document at `path`, as Firestore Values,\n * or `undefined` for a document that is not there.\n *\n * @internal\n */\nexport const readDocument = (\n  path: string,\n  data: Client.DocumentData | undefined,\n): Result.Result<FirestoreValue.FirestoreValue | undefined, FirestoreError> =>\n  FirestoreValue.readDocument(path, data, reader);\n"],"mappings":";;;;;;;AASA,MAAM,UAAU,eAAwD;CAEtE,QAAQ,UAAU,OAAO,MAAM,eAAe,KAAK;CACnD,YAAY,OAAO,IAAI,OAAO,UAAU,GAAG,SAAS,GAAG,WAAW;CAClE,WAAW,UAAU,IAAI,OAAO,SAAS,MAAM,UAAU,MAAM,SAAS;CACxE,eAAe,QAAQ,OAAO,IAAI,WAAW,IAAI,IAAI;CACrD,uBAAuB,OAAO,gBAAgB;CAC9C,YAAY,cAAc,OAAO,UAAU,UAAU,EAAE;CACvD,mBAAmB,OAAO,YAAY;CACtC,aAAa,OAAO,SAAS,OAAO,WAAW,GAAG,MAAM,SAAS,IAAI,IAAI,CAAC;CAC1E,cAAc,QAAQ,SAAS,OAAO,YAAY,GAAG,OAAO,SAAS,IAAI,IAAI,CAAC;AAChF;;AAGA,MAAa,YACX,OACA,cACYA,iBAAe,MAAM,OAAO,OAAO,SAAS,CAAC;;;;;;AAO3D,MAAM,UAAiC,MAAM;CAC3C,IAAI,aAAa,OAAO,WAAW,OAAO,UAAU,WAAW,EAAE,SAAS,EAAE,WAAW;CACvF,IAAI,aAAa,OAAO,UAAU,OAAO,SAAS,WAAW,EAAE,UAAU,EAAE,SAAS;CACpF,IAAI,aAAa,OAAO,mBAAmB,OAAO,aAAa,WAAW,EAAE,IAAI;CAChF,IAAI,aAAa,OAAO,OAAO,OAAO,EAAE,aAAa;AAEvD;;AAGA,MAAa,cACX,UAEAA,iBAAe,QAAQ,OAAO,MAAM;;;;;;;AAQtC,MAAa,gBACX,MACA,SAEAA,iBAAe,aAAa,MAAM,MAAM,MAAM"}

package/dist/firestore/internal/snapshotMetadata.mjs

@@ -0,0 +1,15 @@
+// src/firestore/internal/snapshotMetadata.ts
+/**
+* The extra a client snapshot is built with: its metadata, copied out of the
+* SDK's own object so that the snapshot holds, and prints, only these two
+* fields.
+*
+* @internal
+*/
+const extraOf = (metadata) => ({ metadata: {
+	fromCache: metadata.fromCache,
+	hasPendingWrites: metadata.hasPendingWrites
+} });
+export { extraOf };
+
+//# sourceMappingURL=snapshotMetadata.mjs.map

package/dist/firestore/internal/snapshotMetadata.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotMetadata.mjs","names":[],"sources":["../../../src/firestore/internal/snapshotMetadata.ts"],"sourcesContent":["import type * as ClientDocumentSnapshot from \"../ClientDocumentSnapshot.ts\";\n\n/**\n * The extra a client snapshot is built with: its metadata, copied out of the\n * SDK's own object so that the snapshot holds, and prints, only these two\n * fields.\n *\n * @internal\n */\nexport const extraOf = (\n  metadata: ClientDocumentSnapshot.SnapshotMetadata,\n): { readonly metadata: ClientDocumentSnapshot.SnapshotMetadata } => ({\n  metadata: { fromCache: metadata.fromCache, hasPendingWrites: metadata.hasPendingWrites },\n});\n"],"mappings":";;;;;;;;AASA,MAAa,WACX,cACoE,EACpE,UAAU;CAAE,WAAW,SAAS;CAAW,kBAAkB,SAAS;AAAiB,EACzF"}

package/dist/functions/CallableClient.d.mts

@@ -0,0 +1,139 @@
+import { ClientFunctions } from "./ClientFunctions.mjs";
+import { Effect } from "effect";
+import * as Callable from "@visiolab/effect-firebase/functions/Callable";
+import * as CallableError from "@visiolab/effect-firebase/functions/CallableError";
+import * as FunctionGroup from "@visiolab/effect-firebase/functions/FunctionGroup";
+declare namespace CallableClient_d_exports {
+  export { Client, Members, Method, make };
+}
+/**
+ * A client of one Callable: a function from its Payload to an Effect of its
+ * success value, failing with its declared errors or a `CallableError`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type Method<C extends Callable.Any> = (payload: Callable.Payload<C>) => Effect.Effect<Callable.Success<C>, Callable.Error<C> | CallableError.CallableError>;
+/**
+ * What {@link make} returns: one {@link Method} per Callable, keyed by the
+ * Callable's name. For a Function Group, one per Callable member.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type Client<T extends Callable.Any | FunctionGroup.Any> = { readonly [C in Members<T> as C["name"]]: Method<C>; };
+/**
+ * The Callables a client of `T` calls: the Callable members of a Function
+ * Group, or the Callable itself. Members of other kinds are left out.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Members<T extends Callable.Any | FunctionGroup.Any> = T extends FunctionGroup.Any ? FunctionGroup.Members<T, Callable.Any> : T;
+/**
+ * Builds the client of a Callable in no group, or of every Callable member of
+ * a Function Group.
+ *
+ * **When to use**
+ *
+ * Use to call Callables from the browser or any other client SDK program.
+ *
+ * **Details**
+ *
+ * Returns a record keyed by Callable name: `const { greet } = yield*
+ * CallableClient.make(Greet)` for a Callable in no group, and
+ * `const users = yield* CallableClient.make(Users)` for a group, where
+ * `users.create` calls `users-create`. A group's members of other kinds, which
+ * no client calls, are left out. The region of the
+ * {@link ClientFunctions.ClientFunctions} in context is bound once, here.
+ *
+ * Build a member's client from its group. A client built from the member on
+ * its own calls the name without the group's prefix, which the server doesn't
+ * export, and fails with `not-found`. Nothing checks this at runtime.
+ *
+ * Each call encodes the Payload with `Schema.toCodecJson`, sends it as is
+ * through the SDK's `httpsCallable`, and decodes the answer the same way.
+ *
+ * When the server answers with an error, the client strips the `functions/`
+ * prefix from its code and decodes its `details` against the declared errors
+ * that carry that code. It fails with the decoded error, so `Effect.catchTag`
+ * recovers from it. Every other failure is a
+ * {@link CallableError.CallableError}:
+ *
+ * - `EncodeError` when the Payload doesn't encode. Nothing is sent.
+ * - `DecodeError` when the success value doesn't decode, the `details` of
+ *   an error don't decode against the declared errors with its code, as after
+ *   the server and the client drift apart, or the answer isn't one the SDK
+ *   can read: not a JSON object, or one without `data`.
+ * - `ResponseError` when the server answers with a code no declared error
+ *   carries, or without details, as on a defect. `not-found` usually means a
+ *   wrong region, or a name the server doesn't export, such as a group's
+ *   member called without its group. A `deadline-exceeded` the server sends
+ *   is a `ResponseError` too.
+ * - `TransportError` when no answer arrived: a network failure, the SDK's
+ *   own timeout (`deadline-exceeded`), a cancelled call, or a deleted
+ *   Functions instance. The SDK appends the HTTP status of an answer to its
+ *   error's message as ` [<status>]`, and status 0 to a network failure. The
+ *   client treats an error without that suffix, or with status 0, as no
+ *   answer.
+ *
+ * Each call runs in a `kind: "client"` span named `CallableClient.<deployed
+ * name>`, such as `CallableClient.users-create`, with the attributes
+ * `rpc.system: "firebase_callable"`, `rpc.method` (the Callable's name),
+ * `rpc.service` (the group, for a member) and `faas.name` (the deployed name).
+ * The span isn't linked to the server's span of the same call: the two land in
+ * separate traces. It carries no uid; add one with `Effect.annotateCurrentSpan`
+ * around the call when you want it.
+ *
+ * @example Injecting a client as a service
+ * ```ts
+ * import { Context, Layer, Schema } from "effect";
+ * import { Callable } from "@visiolab/effect-firebase/functions";
+ * import { CallableClient } from "@visiolab/effect-firebase-client/functions";
+ *
+ * const Greet = Callable.make("greet", {
+ *   payload: { name: Schema.String },
+ *   success: Schema.String,
+ * });
+ *
+ * class GreetClient extends Context.Service<GreetClient, CallableClient.Client<typeof Greet>>()(
+ *   "app/GreetClient",
+ * ) {
+ *   static readonly layer = Layer.effect(GreetClient, CallableClient.make(Greet));
+ * }
+ * ```
+ *
+ * @example Calling the members of a group
+ * ```ts
+ * import { Effect, Schema } from "effect";
+ * import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+ * import { CallableClient } from "@visiolab/effect-firebase-client/functions";
+ *
+ * const CreateUser = Callable.make("create", {
+ *   payload: { name: Schema.String },
+ *   success: Schema.String,
+ * });
+ *
+ * class Users extends FunctionGroup.make("users").add(CreateUser) {}
+ *
+ * const program = Effect.gen(function* () {
+ *   const users = yield* CallableClient.make(Users);
+ *   // Calls `users-create`.
+ *   return yield* users.create({ name: "Ada" });
+ * });
+ * ```
+ *
+ * @see {@link ClientFunctions.ClientFunctions} for the region and emulator it calls
+ * @see {@link Functions.make} for serving a Callable in no group
+ * @see {@link Functions.group} for serving the members of a group
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const make: <T extends Callable.Any | FunctionGroup.Any>(target: T) => Effect.Effect<Client<T>, never, ClientFunctions>;
+export { CallableClient_d_exports };
+//# sourceMappingURL=CallableClient.d.mts.map