@visiolab/effect-firebase-admin 0.0.0-stage → 0.3.0

package/dist/firestore/AdminFirestoreValue.mjs

@@ -0,0 +1,62 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { fromAdmin as fromAdmin$1, toAdmin as toAdmin$1 } from "./internal/firestoreValue.mjs";
+// src/firestore/AdminFirestoreValue.ts
+var AdminFirestoreValue_exports = /* @__PURE__ */ __exportAll({
+	fromAdmin: () => fromAdmin,
+	toAdmin: () => toAdmin
+});
+/**
+* Turns a Firestore Value into the value the Admin SDK writes into
+* `firestore`.
+*
+* **When to use**
+*
+* Use to write what a model encodes to through the Admin SDK itself.
+*
+* **Details**
+*
+* The portable `Timestamp`, `GeoPoint`, bytes and sentinels become the Admin
+* SDK's own. A `DocumentPath` becomes `firestore.doc(path)`, so it points into
+* that database. Map keys are kept as they are, so the dotted field paths of an
+* update stay field paths.
+*
+* It throws for anything that is not a Firestore Value, such as one of the
+* Admin SDK's own values or a class instance cast past the type. What
+* {@link FirestoreValue.toCodecFirestore} encodes is always a Firestore Value.
+*
+* @see {@link fromAdmin} for the other direction
+*
+* @stability unstable
+* @category conversions
+* @since 0.2.0
+*/
+const toAdmin = toAdmin$1;
+/**
+* Turns a value the Admin SDK read into a Firestore Value.
+*
+* **When to use**
+*
+* Use to decode what the Admin SDK itself read through a model, with
+* {@link FirestoreValue.toCodecFirestore}.
+*
+* **Details**
+*
+* The Admin SDK's `Timestamp`, `GeoPoint`, bytes and sentinels become their
+* portable forms. A `DocumentReference` becomes the `DocumentPath` it points
+* at, since Firestore stores nothing else of it;
+* {@link FirestoreSchema.DocumentReference} reads that back into the collection
+* it names.
+*
+* Fails with a {@link Firestore.FirestoreError} naming the field for a value
+* that is not a Firestore Value, such as a vector.
+*
+* @see {@link toAdmin} for the other direction
+*
+* @stability unstable
+* @category conversions
+* @since 0.2.0
+*/
+const fromAdmin = fromAdmin$1;
+export { AdminFirestoreValue_exports, fromAdmin, toAdmin };
+
+//# sourceMappingURL=AdminFirestoreValue.mjs.map

package/dist/firestore/AdminFirestoreValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminFirestoreValue.mjs","names":["internal.toAdmin","internal.fromAdmin"],"sources":["../../src/firestore/AdminFirestoreValue.ts"],"sourcesContent":["/**\n * Maps between Firestore Values, the portable values a model encodes to, and\n * the values the Admin SDK reads and writes.\n *\n * {@link AdminFirestore} applies it on every read and write. Use it directly to\n * read or write a model through the Admin SDK itself, such as through\n * {@link AdminFirestore.instance}.\n *\n * @example Writing a model through the Admin SDK\n * ```ts\n * import { Schema } from \"effect\";\n * import { FirestoreModel, FirestoreValue } from \"@visiolab/effect-firebase/firestore\";\n * import { AdminFirestoreValue } from \"@visiolab/effect-firebase-admin/firestore\";\n * import { type DocumentData, getFirestore } from \"firebase-admin/firestore\";\n *\n * class Post extends FirestoreModel.Class<Post>(\"Post\")({\n *   title: Schema.String,\n * }) {}\n *\n * const firestore = getFirestore();\n * const encoded = Schema.encodeSync(FirestoreValue.toCodecFirestore(Post.create))({\n *   title: \"Hello\",\n * });\n * await firestore\n *   .doc(\"posts/hello\")\n *   .set(AdminFirestoreValue.toAdmin(encoded, firestore) as DocumentData);\n * ```\n *\n * @see {@link ClientFirestoreValue} for the client SDK's mapping\n *\n * @stability unstable\n * @since 0.2.0\n */\nimport type { Result } from \"effect\";\nimport type { FirestoreError } from \"@visiolab/effect-firebase/firestore/Firestore\";\nimport type { FirestoreValue } from \"@visiolab/effect-firebase/firestore/FirestoreValue\";\nimport type { Firestore } from \"firebase-admin/firestore\";\nimport * as internal from \"./internal/firestoreValue.ts\";\n\n/**\n * Turns a Firestore Value into the value the Admin SDK writes into\n * `firestore`.\n *\n * **When to use**\n *\n * Use to write what a model encodes to through the Admin SDK itself.\n *\n * **Details**\n *\n * The portable `Timestamp`, `GeoPoint`, bytes and sentinels become the Admin\n * SDK's own. A `DocumentPath` becomes `firestore.doc(path)`, so it points into\n * that database. Map keys are kept as they are, so the dotted field paths of an\n * update stay field paths.\n *\n * It throws for anything that is not a Firestore Value, such as one of the\n * Admin SDK's own values or a class instance cast past the type. What\n * {@link FirestoreValue.toCodecFirestore} encodes is always a Firestore Value.\n *\n * @see {@link fromAdmin} for the other direction\n *\n * @stability unstable\n * @category conversions\n * @since 0.2.0\n */\nexport const toAdmin: (value: FirestoreValue, firestore: Firestore) => unknown = internal.toAdmin;\n\n/**\n * Turns a value the Admin SDK read into a Firestore Value.\n *\n * **When to use**\n *\n * Use to decode what the Admin SDK itself read through a model, with\n * {@link FirestoreValue.toCodecFirestore}.\n *\n * **Details**\n *\n * The Admin SDK's `Timestamp`, `GeoPoint`, bytes and sentinels become their\n * portable forms. A `DocumentReference` becomes the `DocumentPath` it points\n * at, since Firestore stores nothing else of it;\n * {@link FirestoreSchema.DocumentReference} reads that back into the collection\n * it names.\n *\n * Fails with a {@link Firestore.FirestoreError} naming the field for a value\n * that is not a Firestore Value, such as a vector.\n *\n * @see {@link toAdmin} for the other direction\n *\n * @stability unstable\n * @category conversions\n * @since 0.2.0\n */\nexport const fromAdmin: (value: unknown) => Result.Result<FirestoreValue, FirestoreError> =\n  internal.fromAdmin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,MAAa,UAAoEA;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BjF,MAAa,YACXC"}

package/dist/firestore/index.d.mts

@@ -0,0 +1,3 @@
+import { AdminFirestore_d_exports } from "./AdminFirestore.mjs";
+import { AdminFirestoreValue_d_exports } from "./AdminFirestoreValue.mjs";
+export { AdminFirestore_d_exports as AdminFirestore, AdminFirestoreValue_d_exports as AdminFirestoreValue };

package/dist/firestore/index.mjs

@@ -0,0 +1,3 @@
+import { AdminFirestore_exports } from "./AdminFirestore.mjs";
+import { AdminFirestoreValue_exports } from "./AdminFirestoreValue.mjs";
+export { AdminFirestore_exports as AdminFirestore, AdminFirestoreValue_exports as AdminFirestoreValue };

package/dist/firestore/internal/firestore.mjs

@@ -0,0 +1,135 @@
+import { App } from "../../app/App.mjs";
+import { readDocument, toAdmin } from "./firestoreValue.mjs";
+import { Context, Effect, Result } from "effect";
+import { FirebaseError } from "firebase-admin/app";
+import * as Firestore$2 from "@visiolab/effect-firebase/firestore/Firestore";
+import * as Admin from "firebase-admin/firestore";
+// src/firestore/internal/firestore.ts
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase-admin/firestore/AdminFirestore";
+/** @internal */
+const TransactionTypeId = "~@visiolab/effect-firebase-admin/firestore/AdminFirestore/AdminTransaction";
+/**
+* Opens the database the options name.
+*
+* Settings can only be handed over through `initializeFirestore`, which refuses
+* a database already opened with different ones, 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 that disagree is the mistake it reports.
+*/
+const open = (app, options) => {
+	const databaseId = options?.databaseId;
+	if (options?.preferRest === void 0) return databaseId === void 0 ? Admin.getFirestore(app) : Admin.getFirestore(app, databaseId);
+	const settings = { preferRest: options.preferRest };
+	return databaseId === void 0 ? Admin.initializeFirestore(app, settings) : Admin.initializeFirestore(app, settings, databaseId);
+};
+const firestoreError = (message) => (cause) => new Firestore$2.FirestoreError({
+	message,
+	code: cause instanceof FirebaseError ? cause.code : void 0,
+	cause
+});
+/**
+* Opens the database the options name on the {@link App.App} in context.
+*
+* The SDK memoizes a database on the app itself, so there is nothing to release
+* here.
+*
+* @internal
+*/
+const openDatabase = Effect.fnUntraced(function* (options) {
+	const app = yield* App;
+	return open(app, options);
+});
+/**
+* Calls the Admin SDK, failing with `message` for whatever it throws or
+* rejects with. Writes into a transaction are queued rather than sent, so they
+* answer straight away - or throw, where the transaction refuses them.
+*/
+const call = (message, f) => Effect.tryPromise({
+	try: () => Promise.resolve(f()),
+	catch: firestoreError(message)
+});
+/**
+* A document's data as Firestore Values, or `undefined` for one that is not
+* there. A document holding a value outside the Firestore Value union, such as
+* a vector, fails to read.
+*/
+const dataOf = (path, data) => readDocument(path, data);
+const documentReadOf = (path, snapshot) => Result.map(dataOf(path, snapshot.data()), (data) => ({ data }));
+const queryReadOf = (query) => Result.map(Result.all(query.docs.map((snapshot) => Result.map(dataOf(snapshot.ref.path, snapshot.data()), (data) => ({
+	path: snapshot.ref.path,
+	data
+})))), (docs) => ({ docs }));
+/** The Admin SDK query `selector` names, and what it is called in a failure. */
+const queryOf = (firestore, selector) => selector._tag === "CollectionGroup" ? {
+	query: () => firestore.collectionGroup(selector.id),
+	name: `the collection group "${selector.id}"`
+} : {
+	query: () => firestore.collection(selector.path),
+	name: `the collection "${selector.path}"`
+};
+/** Reads many documents, through the database or a transaction. */
+const getDocs = (firestore, get) => (selector) => {
+	const { query, name } = queryOf(firestore, selector);
+	return Effect.flatMap(call(`Failed to read ${name}`, () => get(query())), (snapshot) => Effect.fromResult(queryReadOf(snapshot)));
+};
+/**
+* The reads and writes of one attempt at a transaction, which, unlike the
+* client's, can read many documents.
+*/
+const transactionOperations = (firestore, tx) => ({
+	getDoc: (path) => Effect.flatMap(call(`Failed to read the document "${path}"`, () => tx.get(firestore.doc(path))), (snapshot) => Effect.fromResult(documentReadOf(path, snapshot))),
+	getDocs: getDocs(firestore, (query) => tx.get(query)),
+	setDoc: (path, data) => call(`Failed to write the document "${path}"`, () => {
+		tx.set(firestore.doc(path), toAdmin(data, firestore));
+	}),
+	updateDoc: (path, data) => call(`Failed to update the document "${path}"`, () => {
+		tx.update(firestore.doc(path), toAdmin(data, firestore));
+	})
+});
+/**
+* The service over a database already opened.
+*
+* The key a transaction body finds its
+* {@link AdminFirestore.AdminTransaction} 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 fromDatabase = (firestore, AdminTransaction) => {
+	const toAdmin$1 = (data) => toAdmin(data, firestore);
+	const service = Firestore$2.make({
+		getDoc: (path) => Effect.flatMap(call(`Failed to read the document "${path}"`, () => firestore.doc(path).get()), (snapshot) => Effect.fromResult(documentReadOf(path, snapshot))),
+		getDocs: getDocs(firestore, (query) => query.get()),
+		setDoc: (path, data) => Effect.asVoid(call(`Failed to write the document "${path}"`, () => firestore.doc(path).set(toAdmin$1(data)))),
+		updateDoc: (path, data) => Effect.asVoid(call(`Failed to update the document "${path}"`, () => firestore.doc(path).update(toAdmin$1(data)))),
+		addDoc: (path, data) => Effect.map(call(`Failed to add a document to "${path}"`, () => firestore.collection(path).add(toAdmin$1(data))), (added) => added.id),
+		streamDoc: (path) => Firestore$2.streamFromListener({
+			subscribe: (onNext, onError) => firestore.doc(path).onSnapshot(onNext, onError),
+			onError: firestoreError(`Failed to listen to the document "${path}"`),
+			map: (snapshot) => documentReadOf(path, snapshot)
+		}),
+		streamDocs: (selector) => {
+			const { query, name } = queryOf(firestore, selector);
+			return Firestore$2.streamFromListener({
+				subscribe: (onNext, onError) => query().onSnapshot(onNext, onError),
+				onError: firestoreError(`Failed to listen to ${name}`),
+				map: queryReadOf
+			});
+		},
+		runTransaction: Firestore$2.transactionFromCallback({
+			run: (callback, options) => firestore.runTransaction(callback, options),
+			operations: (tx) => transactionOperations(firestore, tx),
+			onError: firestoreError("Failed to run a transaction"),
+			context: (transaction) => Context.make(AdminTransaction, Object.assign(transaction, { [TransactionTypeId]: TransactionTypeId }))
+		})
+	});
+	return Object.assign(service, {
+		[TypeId]: TypeId,
+		instance: firestore
+	});
+};
+export { TransactionTypeId, TypeId, fromDatabase, openDatabase };
+
+//# sourceMappingURL=firestore.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.mjs","names":["Firestore","App.App","firestoreValue.readDocument","firestoreValue.toAdmin","toAdmin"],"sources":["../../../src/firestore/internal/firestore.ts"],"sourcesContent":["import { Context, Effect, Result } from \"effect\";\nimport * as Firestore from \"@visiolab/effect-firebase/firestore/Firestore\";\nimport { FirebaseError } from \"firebase-admin/app\";\nimport * as Admin from \"firebase-admin/firestore\";\nimport * as App from \"../../app/App.ts\";\nimport type * as AdminFirestore from \"../AdminFirestore.ts\";\nimport * as firestoreValue from \"./firestoreValue.ts\";\n\n/** @internal */\nexport const TypeId = \"~@visiolab/effect-firebase-admin/firestore/AdminFirestore\";\n\n/** @internal */\nexport const TransactionTypeId =\n  \"~@visiolab/effect-firebase-admin/firestore/AdminFirestore/AdminTransaction\";\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 with different ones, so they are only passed along\n * when there are some: asking for the default database twice keeps working, and\n * asking for it twice with settings that disagree is the mistake it reports.\n */\nconst open = (app: App.App, options: AdminFirestore.Options | undefined): Admin.Firestore => {\n  const databaseId = options?.databaseId;\n  if (options?.preferRest === undefined) {\n    return databaseId === undefined ? Admin.getFirestore(app) : Admin.getFirestore(app, databaseId);\n  }\n  const settings = { preferRest: options.preferRest };\n  return databaseId === undefined\n    ? Admin.initializeFirestore(app, settings)\n    : Admin.initializeFirestore(app, settings, databaseId);\n};\n\nconst firestoreError = (message: string) => (cause: unknown) =>\n  new Firestore.FirestoreError({\n    message,\n    // Firestore answers over gRPC, whose statuses are numbered rather than\n    // named, so a code only comes back for the failures the Admin SDK raises\n    // itself.\n    code: cause instanceof FirebaseError ? cause.code : undefined,\n    cause,\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, so there is nothing to release\n * here.\n *\n * @internal\n */\nexport const openDatabase = Effect.fnUntraced(function* (options?: AdminFirestore.Options) {\n  const app = yield* App.App;\n  return open(app, options);\n});\n\n/**\n * Calls the Admin SDK, failing with `message` for whatever it throws or\n * rejects with. Writes into a transaction are queued rather than sent, so they\n * answer straight away - or throw, where the transaction refuses them.\n */\nconst call = <A>(message: string, f: () => PromiseLike<A> | A) =>\n  Effect.tryPromise({ try: () => Promise.resolve(f()), catch: firestoreError(message) });\n\n/**\n * A document's data as Firestore Values, or `undefined` for one that is not\n * there. A document holding a value outside the Firestore Value union, such as\n * a vector, fails to read.\n */\nconst dataOf = (\n  path: string,\n  data: Admin.DocumentData | undefined,\n): Result.Result<Firestore.DocumentData | undefined, Firestore.FirestoreError> =>\n  firestoreValue.readDocument(path, data) as Result.Result<\n    Firestore.DocumentData | undefined,\n    Firestore.FirestoreError\n  >;\n\nconst documentReadOf = (\n  path: string,\n  snapshot: Admin.DocumentSnapshot,\n): Result.Result<Firestore.DocumentRead, Firestore.FirestoreError> =>\n  Result.map(dataOf(path, snapshot.data()), (data) => ({ data }));\n\nconst queryReadOf = (\n  query: Admin.QuerySnapshot,\n): Result.Result<Firestore.QueryRead, Firestore.FirestoreError> =>\n  Result.map(\n    Result.all(\n      query.docs.map((snapshot) =>\n        // A document read as one of many is always there.\n        Result.map(dataOf(snapshot.ref.path, snapshot.data()), (data) => ({\n          path: snapshot.ref.path,\n          data: data as Firestore.DocumentData,\n        })),\n      ),\n    ),\n    (docs) => ({ docs }),\n  );\n\n/** The Admin SDK query `selector` names, and what it is called in a failure. */\nconst queryOf = (firestore: Admin.Firestore, selector: Firestore.CollectionSelector) =>\n  selector._tag === \"CollectionGroup\"\n    ? {\n        query: (): Admin.Query => firestore.collectionGroup(selector.id),\n        name: `the collection group \"${selector.id}\"`,\n      }\n    : {\n        query: (): Admin.Query => firestore.collection(selector.path),\n        name: `the collection \"${selector.path}\"`,\n      };\n\n/** Reads many documents, through the database or a transaction. */\nconst getDocs =\n  (firestore: Admin.Firestore, get: (query: Admin.Query) => Promise<Admin.QuerySnapshot>) =>\n  (selector: Firestore.CollectionSelector) => {\n    const { query, name } = queryOf(firestore, selector);\n    return Effect.flatMap(\n      call(`Failed to read ${name}`, () => get(query())),\n      (snapshot) => Effect.fromResult(queryReadOf(snapshot)),\n    );\n  };\n\n/**\n * The reads and writes of one attempt at a transaction, which, unlike the\n * client's, can read many documents.\n */\nconst transactionOperations = (\n  firestore: Admin.Firestore,\n  tx: Admin.Transaction,\n): Required<Firestore.TransactionOperations> => ({\n  getDoc: (path) =>\n    Effect.flatMap(\n      call(`Failed to read the document \"${path}\"`, () => tx.get(firestore.doc(path))),\n      (snapshot) => Effect.fromResult(documentReadOf(path, snapshot)),\n    ),\n  getDocs: getDocs(firestore, (query) => tx.get(query)),\n  setDoc: (path, data) =>\n    call(`Failed to write the document \"${path}\"`, () => {\n      tx.set(firestore.doc(path), firestoreValue.toAdmin(data, firestore) as Admin.DocumentData);\n    }),\n  updateDoc: (path, data) =>\n    call(`Failed to update the document \"${path}\"`, () => {\n      tx.update(\n        firestore.doc(path),\n        firestoreValue.toAdmin(data, firestore) as Admin.UpdateData<Admin.DocumentData>,\n      );\n    }),\n});\n\n/**\n * The service over a database already opened.\n *\n * The key a transaction body finds its\n * {@link AdminFirestore.AdminTransaction} under is handed in by the public\n * module that defines it, so that this one only imports it as a type and the\n * two do not import each other.\n *\n * @internal\n */\nexport const fromDatabase = (\n  firestore: Admin.Firestore,\n  AdminTransaction: typeof AdminFirestore.AdminTransaction,\n): AdminFirestore.AdminFirestore & Firestore.Firestore => {\n  const toAdmin = (data: Firestore.DocumentData) => firestoreValue.toAdmin(data, firestore);\n\n  const service = Firestore.make({\n    getDoc: (path) =>\n      Effect.flatMap(\n        call(`Failed to read the document \"${path}\"`, () => firestore.doc(path).get()),\n        (snapshot) => Effect.fromResult(documentReadOf(path, snapshot)),\n      ),\n\n    getDocs: getDocs(firestore, (query) => query.get()),\n\n    setDoc: (path, data) =>\n      Effect.asVoid(\n        call(`Failed to write the document \"${path}\"`, () =>\n          firestore.doc(path).set(toAdmin(data) as Admin.DocumentData),\n        ),\n      ),\n\n    updateDoc: (path, data) =>\n      Effect.asVoid(\n        call(`Failed to update the document \"${path}\"`, () =>\n          firestore.doc(path).update(toAdmin(data) as Admin.UpdateData<Admin.DocumentData>),\n        ),\n      ),\n\n    addDoc: (path, data) =>\n      Effect.map(\n        call(`Failed to add a document to \"${path}\"`, () =>\n          firestore.collection(path).add(toAdmin(data) as Admin.DocumentData),\n        ),\n        (added) => added.id,\n      ),\n\n    streamDoc: (path) =>\n      Firestore.streamFromListener({\n        subscribe: (onNext, onError) => firestore.doc(path).onSnapshot(onNext, onError),\n        onError: firestoreError(`Failed to listen to the document \"${path}\"`),\n        map: (snapshot: Admin.DocumentSnapshot) => documentReadOf(path, snapshot),\n      }),\n\n    streamDocs: (selector) => {\n      const { query, name } = queryOf(firestore, selector);\n      return Firestore.streamFromListener({\n        subscribe: (onNext, onError) => query().onSnapshot(onNext, onError),\n        onError: firestoreError(`Failed to listen to ${name}`),\n        map: queryReadOf,\n      });\n    },\n\n    runTransaction: Firestore.transactionFromCallback({\n      run: (callback, options) => firestore.runTransaction(callback, options),\n      operations: (tx: Admin.Transaction) => transactionOperations(firestore, tx),\n      onError: firestoreError(\"Failed to run a transaction\"),\n      // The operations read many documents, so the transaction core builds\n      // has a `getDocs`. Branding it in place, rather than a copy, keeps one\n      // object under both keys.\n      context: (transaction) =>\n        Context.make(\n          AdminTransaction,\n          Object.assign(transaction, { [TransactionTypeId]: TransactionTypeId } as const),\n        ),\n    }),\n  });\n\n  // The Admin interface is checked against what `make` built here, except for\n  // the Admin Transaction its `context` offers: the compiler does not check\n  // transaction services on assignment, so the AdminTransaction tests do.\n  const admin: AdminFirestore.AdminFirestore & Firestore.Firestore = Object.assign(service, {\n    [TypeId]: TypeId as typeof TypeId,\n    instance: firestore,\n  });\n  return admin;\n};\n"],"mappings":"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"}

package/dist/firestore/internal/firestoreValue.mjs

@@ -0,0 +1,56 @@
+import { Predicate } from "effect";
+import * as Admin from "firebase-admin/firestore";
+import * as DocumentPath from "@visiolab/effect-firebase/firestore/DocumentPath";
+import * as FieldValue from "@visiolab/effect-firebase/firestore/FieldValue";
+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 Admin SDK writes each kind of Firestore Value into `firestore`. */
+const writer = (firestore) => ({
+	bytes: (bytes) => bytes,
+	timestamp: (ts) => new Admin.Timestamp(ts.seconds, ts.nanoseconds),
+	geoPoint: (point) => new Admin.GeoPoint(point.latitude, point.longitude),
+	documentPath: (ref) => firestore.doc(ref.path),
+	serverTimestamp: () => Admin.FieldValue.serverTimestamp(),
+	increment: (increment) => Admin.FieldValue.increment(increment.by),
+	deleteField: () => Admin.FieldValue.delete(),
+	arrayUnion: (union, walk) => Admin.FieldValue.arrayUnion(...union.elements.map(walk)),
+	arrayRemove: (remove, walk) => Admin.FieldValue.arrayRemove(...remove.elements.map(walk))
+});
+/** @internal */
+const toAdmin = (value, firestore) => FirestoreValue$1.toSdk(value, writer(firestore));
+/** How the Admin SDK's own values read back as Firestore Values. */
+const reader = (u, { walk, fail }) => {
+	if (u instanceof Uint8Array) return u.constructor === Uint8Array ? u : new Uint8Array(u.buffer, u.byteOffset, u.length);
+	if (u instanceof Admin.Timestamp) return Timestamp.makeUnsafe(u.seconds, u.nanoseconds);
+	if (u instanceof Admin.GeoPoint) return GeoPoint.makeUnsafe(u.latitude, u.longitude);
+	if (u instanceof Admin.DocumentReference) return DocumentPath.makeUnsafe(u.path);
+	if (u instanceof Admin.FieldValue) {
+		const sentinel = u;
+		switch (sentinel.methodName) {
+			case "FieldValue.serverTimestamp": return FieldValue.serverTimestamp;
+			case "FieldValue.delete": return FieldValue.deleteField;
+			case "FieldValue.increment":
+				if (Predicate.isNumber(sentinel.operand)) return FieldValue.increment(sentinel.operand);
+				break;
+			case "FieldValue.arrayUnion":
+				if (Array.isArray(sentinel.elements)) return FieldValue.arrayUnion(...sentinel.elements.map(walk));
+				break;
+			case "FieldValue.arrayRemove": if (Array.isArray(sentinel.elements)) return FieldValue.arrayRemove(...sentinel.elements.map(walk));
+		}
+		return fail(`the sentinel ${sentinel.methodName ?? u.constructor.name}`);
+	}
+};
+/** @internal */
+const fromAdmin = (value) => FirestoreValue$1.fromSdk(value, reader);
+/**
+* What the Admin 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 { fromAdmin, readDocument, toAdmin };
+
+//# 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 { Predicate, type Result } from \"effect\";\nimport * as DocumentPath from \"@visiolab/effect-firebase/firestore/DocumentPath\";\nimport * as FieldValue from \"@visiolab/effect-firebase/firestore/FieldValue\";\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 Admin from \"firebase-admin/firestore\";\n\n/** How the Admin SDK writes each kind of Firestore Value into `firestore`. */\nconst writer = (firestore: Admin.Firestore): FirestoreValue.Writer => ({\n  bytes: (bytes) => bytes,\n  timestamp: (ts) => new Admin.Timestamp(ts.seconds, ts.nanoseconds),\n  geoPoint: (point) => new Admin.GeoPoint(point.latitude, point.longitude),\n  documentPath: (ref) => firestore.doc(ref.path),\n  serverTimestamp: () => Admin.FieldValue.serverTimestamp(),\n  increment: (increment) => Admin.FieldValue.increment(increment.by),\n  deleteField: () => Admin.FieldValue.delete(),\n  arrayUnion: (union, walk) => Admin.FieldValue.arrayUnion(...union.elements.map(walk)),\n  arrayRemove: (remove, walk) => Admin.FieldValue.arrayRemove(...remove.elements.map(walk)),\n});\n\n/** @internal */\nexport const toAdmin = (\n  value: FirestoreValue.FirestoreValue,\n  firestore: Admin.Firestore,\n): unknown => FirestoreValue.toSdk(value, writer(firestore));\n\n/** The sentinels' names, as the Admin SDK keeps them. */\ninterface AdminSentinel {\n  readonly methodName?: string;\n  readonly operand?: number;\n  readonly elements?: ReadonlyArray<unknown>;\n}\n\n/** How the Admin SDK's own values read back as Firestore Values. */\nconst reader: FirestoreValue.Reader = (u, { walk, fail }) => {\n  if (u instanceof Uint8Array) {\n    // The Admin SDK reads bytes as a Node `Buffer`.\n    return u.constructor === Uint8Array ? u : new Uint8Array(u.buffer, u.byteOffset, u.length);\n  }\n  if (u instanceof Admin.Timestamp) return Timestamp.makeUnsafe(u.seconds, u.nanoseconds);\n  if (u instanceof Admin.GeoPoint) return GeoPoint.makeUnsafe(u.latitude, u.longitude);\n  if (u instanceof Admin.DocumentReference) return DocumentPath.makeUnsafe(u.path);\n  if (u instanceof Admin.FieldValue) {\n    const sentinel = u as AdminSentinel;\n    switch (sentinel.methodName) {\n      case \"FieldValue.serverTimestamp\":\n        return FieldValue.serverTimestamp;\n      case \"FieldValue.delete\":\n        return FieldValue.deleteField;\n      case \"FieldValue.increment\":\n        if (Predicate.isNumber(sentinel.operand)) return FieldValue.increment(sentinel.operand);\n        break;\n      case \"FieldValue.arrayUnion\":\n        if (Array.isArray(sentinel.elements))\n          return FieldValue.arrayUnion(...sentinel.elements.map(walk));\n        break;\n      case \"FieldValue.arrayRemove\":\n        if (Array.isArray(sentinel.elements))\n          return FieldValue.arrayRemove(...sentinel.elements.map(walk));\n        break;\n    }\n    return fail(`the sentinel ${sentinel.methodName ?? u.constructor.name}`);\n  }\n  return undefined;\n};\n\n/** @internal */\nexport const fromAdmin = (\n  value: unknown,\n): Result.Result<FirestoreValue.FirestoreValue, FirestoreError> =>\n  FirestoreValue.fromSdk(value, reader);\n\n/**\n * What the Admin SDK read for the document at `path`, as Firestore Values, or\n * `undefined` for a document that is not there.\n *\n * @internal\n */\nexport const readDocument = (\n  path: string,\n  data: Admin.DocumentData | undefined,\n): Result.Result<FirestoreValue.FirestoreValue | undefined, FirestoreError> =>\n  FirestoreValue.readDocument(path, data, reader);\n"],"mappings":";;;;;;;;;AAUA,MAAM,UAAU,eAAuD;CACrE,QAAQ,UAAU;CAClB,YAAY,OAAO,IAAI,MAAM,UAAU,GAAG,SAAS,GAAG,WAAW;CACjE,WAAW,UAAU,IAAI,MAAM,SAAS,MAAM,UAAU,MAAM,SAAS;CACvE,eAAe,QAAQ,UAAU,IAAI,IAAI,IAAI;CAC7C,uBAAuB,MAAM,WAAW,gBAAgB;CACxD,YAAY,cAAc,MAAM,WAAW,UAAU,UAAU,EAAE;CACjE,mBAAmB,MAAM,WAAW,OAAO;CAC3C,aAAa,OAAO,SAAS,MAAM,WAAW,WAAW,GAAG,MAAM,SAAS,IAAI,IAAI,CAAC;CACpF,cAAc,QAAQ,SAAS,MAAM,WAAW,YAAY,GAAG,OAAO,SAAS,IAAI,IAAI,CAAC;AAC1F;;AAGA,MAAa,WACX,OACA,cACYA,iBAAe,MAAM,OAAO,OAAO,SAAS,CAAC;;AAU3D,MAAM,UAAiC,GAAG,EAAE,MAAM,WAAW;CAC3D,IAAI,aAAa,YAEf,OAAO,EAAE,gBAAgB,aAAa,IAAI,IAAI,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM;CAE3F,IAAI,aAAa,MAAM,WAAW,OAAO,UAAU,WAAW,EAAE,SAAS,EAAE,WAAW;CACtF,IAAI,aAAa,MAAM,UAAU,OAAO,SAAS,WAAW,EAAE,UAAU,EAAE,SAAS;CACnF,IAAI,aAAa,MAAM,mBAAmB,OAAO,aAAa,WAAW,EAAE,IAAI;CAC/E,IAAI,aAAa,MAAM,YAAY;EACjC,MAAM,WAAW;EACjB,QAAQ,SAAS,YAAjB;GACE,KAAK,8BACH,OAAO,WAAW;GACpB,KAAK,qBACH,OAAO,WAAW;GACpB,KAAK;IACH,IAAI,UAAU,SAAS,SAAS,OAAO,GAAG,OAAO,WAAW,UAAU,SAAS,OAAO;IACtF;GACF,KAAK;IACH,IAAI,MAAM,QAAQ,SAAS,QAAQ,GACjC,OAAO,WAAW,WAAW,GAAG,SAAS,SAAS,IAAI,IAAI,CAAC;IAC7D;GACF,KAAK,0BACH,IAAI,MAAM,QAAQ,SAAS,QAAQ,GACjC,OAAO,WAAW,YAAY,GAAG,SAAS,SAAS,IAAI,IAAI,CAAC;EAElE;EACA,OAAO,KAAK,gBAAgB,SAAS,cAAc,EAAE,YAAY,MAAM;CACzE;AAEF;;AAGA,MAAa,aACX,UAEAA,iBAAe,QAAQ,OAAO,MAAM;;;;;;;AAQtC,MAAa,gBACX,MACA,SAEAA,iBAAe,aAAa,MAAM,MAAM,MAAM"}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@visiolab/effect-firebase-admin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.0",
+  "description": "Firebase Admin SDK implementation of the @visiolab/effect-firebase services.",
+  "keywords": [
+    "effect",
+    "firebase",
+    "firebase-admin",
+    "typescript"
+  ],
+  "homepage": "https://github.com/VisioLab/effect-firebase",
+  "bugs": {
+    "url": "https://github.com/VisioLab/effect-firebase/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VisioLab/effect-firebase.git",
+    "directory": "packages/admin"
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist/**/*.mjs",
+    "dist/**/*.mjs.map",
+    "dist/**/*.d.mts",
+    "dist/**/*.d.mts.map"
+  ],
+  "type": "module",
+  "sideEffects": [],
+  "exports": {
+    "./app": "./dist/app/index.mjs",
+    "./app/App": "./dist/app/App.mjs",
+    "./auth": "./dist/auth/index.mjs",
+    "./auth/Auth": "./dist/auth/Auth.mjs",
+    "./firestore": "./dist/firestore/index.mjs",
+    "./firestore/AdminFirestore": "./dist/firestore/AdminFirestore.mjs",
+    "./firestore/AdminFirestoreValue": "./dist/firestore/AdminFirestoreValue.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^4.1.0",
+    "effect": "4.1.0",
+    "firebase-admin": "^14.5.0",
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
+    "vite-plus": "1.4.0",
+    "vitest": "5.0.5",
+    "@visiolab/effect-firebase": "^0.3.0"
+  },
+  "peerDependencies": {
+    "effect": "~4.1.0",
+    "firebase-admin": "^14.5.0",
+    "@visiolab/effect-firebase": "^0.3.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
 }

package/src/app/App.ts

@@ -0,0 +1,158 @@
+/**
+ * The Firebase Admin SDK app as an Effect service.
+ *
+ * Every other service in this package, such as {@link Auth.Auth} and
+ * {@link AdminFirestore.AdminFirestore}, is built on the {@link App} in
+ * context. Provide it with {@link layer}, or hand it an app the host already
+ * initialized.
+ *
+ * @example Initializing the app for a program
+ * ```ts
+ * import { Effect } from "effect";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ *
+ * const program = Effect.gen(function* () {
+ *   const app = yield* App.App;
+ *   yield* Effect.log(`Running against ${app.name}`);
+ * });
+ *
+ * program.pipe(Effect.provide(App.layer()));
+ * ```
+ *
+ * @see [Add the Firebase Admin SDK to your server](https://firebase.google.com/docs/admin/setup)
+ *
+ * @stability unstable
+ * @since 0.1.0
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import type * as Admin from "firebase-admin/app";
+// Only the module's documentation links to these.
+// oxlint-disable-next-line no-unused-vars
+import type * as Auth from "../auth/Auth.ts";
+// oxlint-disable-next-line no-unused-vars
+import type * as AdminFirestore from "../firestore/AdminFirestore.ts";
+import * as internalApp from "./internal/app.ts";
+
+/**
+ * A Firebase Admin SDK app: the SDK's own `App`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface App extends Admin.App {}
+
+/**
+ * Service key for the Firebase Admin SDK app.
+ *
+ * **When to use**
+ *
+ * Use to provide an app the host already initialized, such as one from
+ * `getApp()`, with `Layer.succeed`. Nothing deletes an app provided this way.
+ *
+ * @example Providing an app the host initialized
+ * ```ts
+ * import { Layer } from "effect";
+ * import { getApp } from "firebase-admin/app";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ *
+ * const AppLive = Layer.succeed(App.App, getApp());
+ * ```
+ *
+ * @see {@link layer} for initializing the app for the lifetime of a layer
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.1.0
+ */
+export const App = Context.Service<App>("@visiolab/effect-firebase-admin/app/App");
+
+/**
+ * Fails {@link make} and {@link layer} when the Admin SDK refuses to initialize
+ * the app, with what it threw as the `cause`.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.1.0
+ */
+export class AppError extends Schema.TaggedError<AppError, { readonly brand: unique symbol }>()(
+  "AppError",
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {}
+
+/**
+ * Initializes a Firebase Admin SDK app, and deletes it again when the
+ * surrounding scope closes.
+ *
+ * **When to use**
+ *
+ * Use to build the app inside an effect of your own. Most programs provide it
+ * with {@link layer} instead.
+ *
+ * **Details**
+ *
+ * Takes the arguments of `initializeApp(options, name)`. With no options, the
+ * Admin SDK initializes the app from the `FIREBASE_CONFIG` environment variable
+ * and application default credentials.
+ *
+ * An app already registered under the same name is not deleted when the scope
+ * closes. The Admin SDK only hands back that app when the request matches how
+ * it was created: it rejects auto-init against explicit options, and rejects
+ * reuse outright when either side carries a credential or an `httpAgent`. To
+ * pick up an app the host initialized, provide `getApp()` as {@link App}.
+ *
+ * Fails with an {@link AppError} when the Admin SDK refuses to initialize the
+ * app. A failure to delete the app is logged as a warning, not raised.
+ *
+ * @see {@link layer} for the same as a layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = Effect.fn("App.make")(function* (options?: Admin.AppOptions, name?: string) {
+  const { app } = yield* Effect.acquireRelease(
+    Effect.try({
+      try: () => internalApp.initialize(options, name),
+      catch: (cause) =>
+        new AppError({ message: "Failed to initialize the Firebase Admin SDK app", cause }),
+    }),
+    internalApp.release,
+  );
+  return app;
+});
+
+/**
+ * A layer that initializes a Firebase Admin SDK app for the lifetime of the
+ * layer.
+ *
+ * **When to use**
+ *
+ * Use when this program owns the app. Where the host has already initialized
+ * one, provide that app as {@link App} instead.
+ *
+ * **Details**
+ *
+ * Takes the arguments of `initializeApp(options, name)`. With no options, the
+ * Admin SDK initializes the app from the `FIREBASE_CONFIG` environment variable
+ * and application default credentials.
+ *
+ * @example Initializing a named app with explicit options
+ * ```ts
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ *
+ * const AppLive = App.layer({ projectId: "my-project" }, "secondary");
+ * ```
+ *
+ * @see {@link make} for how the app is initialized and torn down
+ * @see {@link App} for providing an app the host initialized
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.1.0
+ */
+export const layer = (options?: Admin.AppOptions, name?: string): Layer.Layer<App, AppError> =>
+  Layer.effect(App, make(options, name));

package/src/app/index.ts

@@ -0,0 +1,7 @@
+/**
+ * The Firebase Admin SDK app as an Effect service.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ */
+export * as App from "./App.ts";

package/src/app/internal/app.ts

@@ -0,0 +1,35 @@
+import { Effect } from "effect";
+import { defaultAppName } from "@visiolab/effect-firebase/app/App";
+import * as Admin from "firebase-admin/app";
+import type * as App from "../App.ts";
+
+/**
+ * The app together with whether we are the ones who initialized it.
+ *
+ * @internal
+ */
+export interface Initialized {
+  readonly app: App.App;
+  readonly owned: boolean;
+}
+
+/** @internal */
+export const initialize = (options?: Admin.AppOptions, name?: string): Initialized => {
+  // An app that is already registered under this name was initialized by
+  // somebody else - typically the hosting runtime - so ending its lifecycle is
+  // not ours to do. `initializeApp` still throws when that app was configured
+  // differently, so conflicting configuration is not swallowed here.
+  const owned = !Admin.getApps().some((app) => app.name === (name ?? defaultAppName));
+  return { app: Admin.initializeApp(options, name), owned };
+};
+
+/** @internal */
+export const release = ({ app, owned }: Initialized): Effect.Effect<void> =>
+  owned
+    ? Effect.tryPromise(() => Admin.deleteApp(app)).pipe(
+        Effect.ignore({
+          log: "Warn",
+          message: `Failed to delete the Firebase Admin SDK app "${app.name}"`,
+        }),
+      )
+    : Effect.void;