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

package/src/auth/Auth.ts

@@ -0,0 +1,258 @@
+/**
+ * Firebase Authentication on the Admin SDK, as an Effect service.
+ *
+ * {@link Auth} wraps the calls server code uses most, such as verifying ID
+ * tokens and managing users. Every call fails with an {@link AuthError}, and
+ * {@link Auth.use} reaches the rest of the Admin SDK.
+ *
+ * @example Verifying an ID token
+ * ```ts
+ * import { Effect, Layer } from "effect";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ * import { Auth } from "@visiolab/effect-firebase-admin/auth";
+ *
+ * const uidOf = (idToken: string) =>
+ *   Effect.gen(function* () {
+ *     const auth = yield* Auth.Auth;
+ *     const token = yield* auth.verifyIdToken(idToken, true);
+ *     return token.uid;
+ *   });
+ *
+ * const AuthLive = Auth.layer.pipe(Layer.provide(App.layer()));
+ *
+ * uidOf("<id token>").pipe(Effect.provide(AuthLive));
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import { FirebaseError } from "firebase-admin/app";
+import * as Admin from "firebase-admin/auth";
+import * as App from "../app/App.ts";
+
+/**
+ * Fails a call on {@link Auth} when the Admin SDK rejects it, with what it
+ * threw as the `cause`.
+ *
+ * Match on `code` to tell failures apart, such as `auth/user-not-found` or
+ * `auth/id-token-revoked`.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.1.0
+ */
+export class AuthError extends Schema.TaggedError<AuthError, { readonly brand: unique symbol }>()(
+  "AuthError",
+  {
+    message: Schema.String,
+    /** The `service/string-code` the Admin SDK reported, such as `auth/user-not-found`. */
+    code: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {}
+
+const authError = (message: string) => (cause: unknown) =>
+  new AuthError({
+    message,
+    code: cause instanceof FirebaseError ? cause.code : undefined,
+    cause,
+  });
+
+/**
+ * Firebase Authentication for a single app.
+ *
+ * Each call is the Admin SDK's method of the same name, with the same
+ * arguments, failing with an {@link AuthError} and traced as a span named
+ * `Auth.<method>`. Use {@link Auth.use} for anything else the Admin SDK offers.
+ *
+ * The Admin SDK cannot abort a request in flight, so interrupting a call does
+ * not stop it: the request still runs to completion.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface Auth {
+  /**
+   * Runs `f` against the Admin SDK's own `Auth`, failing with an
+   * {@link AuthError} when it throws or rejects.
+   *
+   * **When to use**
+   *
+   * Use for the Admin SDK calls this service does not wrap, such as
+   * `setCustomUserClaims` or `listUsers`. Prefer the wrapped methods where one
+   * exists: they name the failure in the error's message.
+   *
+   * @example Setting custom claims
+   * ```ts
+   * import { Effect } from "effect";
+   * import { Auth } from "@visiolab/effect-firebase-admin/auth";
+   *
+   * const makeAdmin = (uid: string) =>
+   *   Effect.gen(function* () {
+   *     const auth = yield* Auth.Auth;
+   *     yield* auth.use((sdk) => sdk.setCustomUserClaims(uid, { admin: true }));
+   *   });
+   * ```
+   */
+  readonly use: <A>(f: (auth: Admin.Auth) => PromiseLike<A> | A) => Effect.Effect<A, AuthError>;
+  /**
+   * Verifies a Firebase ID token and decodes it.
+   *
+   * With `checkRevoked`, it also fails for a token whose session was revoked or
+   * whose user is disabled, at the cost of a request to the Auth backend.
+   *
+   * @see {@link Auth.createCustomToken} for minting a token a client signs in with
+   */
+  readonly verifyIdToken: (
+    idToken: string,
+    checkRevoked?: boolean,
+  ) => Effect.Effect<Admin.DecodedIdToken, AuthError>;
+  /**
+   * Mints a custom token for `uid`, which a client signs in with through
+   * `signInWithCustomToken`.
+   *
+   * `developerClaims` end up in the ID tokens of that session.
+   *
+   * @see {@link Auth.verifyIdToken} for checking the ID token a client sends back
+   */
+  readonly createCustomToken: (
+    uid: string,
+    developerClaims?: object,
+  ) => Effect.Effect<string, AuthError>;
+  /**
+   * Reads the user with `uid`.
+   *
+   * Fails with `auth/user-not-found` when there is none.
+   *
+   * @see {@link Auth.getUserByEmail} for looking a user up by email
+   */
+  readonly getUser: (uid: string) => Effect.Effect<Admin.UserRecord, AuthError>;
+  /**
+   * Reads the user with `email`.
+   *
+   * Fails with `auth/user-not-found` when there is none.
+   *
+   * @see {@link Auth.getUser} for looking a user up by uid
+   */
+  readonly getUserByEmail: (email: string) => Effect.Effect<Admin.UserRecord, AuthError>;
+  /**
+   * Creates a user, under the `uid` in `properties` or one the Auth backend
+   * picks.
+   *
+   * @see {@link Auth.updateUser} for changing a user that exists
+   */
+  readonly createUser: (
+    properties: Admin.CreateRequest,
+  ) => Effect.Effect<Admin.UserRecord, AuthError>;
+  /**
+   * Changes the properties of the user with `uid`.
+   *
+   * @see {@link Auth.createUser} for creating one
+   */
+  readonly updateUser: (
+    uid: string,
+    properties: Admin.UpdateRequest,
+  ) => Effect.Effect<Admin.UserRecord, AuthError>;
+  /**
+   * Deletes the user with `uid`.
+   */
+  readonly deleteUser: (uid: string) => Effect.Effect<void, AuthError>;
+}
+
+/**
+ * Service key for Firebase Authentication.
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.1.0
+ */
+export const Auth = Context.Service<Auth>("@visiolab/effect-firebase-admin/auth/Auth");
+
+/**
+ * Builds {@link Auth} on the {@link App.App} in context.
+ *
+ * **When to use**
+ *
+ * Use to build the service inside an effect of your own. Most programs provide
+ * it with {@link layer} instead.
+ *
+ * **Details**
+ *
+ * Building the service cannot fail. `getAuth` only throws for an app that was
+ * already deleted or is not an app at all. Both are wiring mistakes, so they
+ * are defects, and {@link AuthError} only ever means that a call failed.
+ *
+ * @see {@link layer} for the same as a layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = Effect.gen(function* () {
+  const app = yield* App.App;
+
+  // `getAuth` memoizes the service on the app itself, so there is nothing to
+  // release here.
+  const auth = Admin.getAuth(app);
+
+  const call = <A>(
+    span: string,
+    message: string,
+    f: (auth: Admin.Auth) => PromiseLike<A> | A,
+  ): Effect.Effect<A, AuthError> =>
+    Effect.tryPromise({
+      // `Promise.resolve` covers the calls that hand back a plain value, and
+      // keeps a synchronous throw on the `catch` path rather than the die one.
+      try: () => Promise.resolve(f(auth)),
+      catch: authError(message),
+    }).pipe(Effect.withSpan(`Auth.${span}`));
+
+  return Auth.of({
+    use: (f) => call("use", "A Firebase Authentication call failed", f),
+    verifyIdToken: (idToken, checkRevoked) =>
+      call("verifyIdToken", "Failed to verify the ID token", (auth) =>
+        auth.verifyIdToken(idToken, checkRevoked),
+      ),
+    createCustomToken: (uid, developerClaims) =>
+      call("createCustomToken", `Failed to create a custom token for "${uid}"`, (auth) =>
+        auth.createCustomToken(uid, developerClaims),
+      ),
+    getUser: (uid) =>
+      call("getUser", `Failed to get the user "${uid}"`, (auth) => auth.getUser(uid)),
+    getUserByEmail: (email) =>
+      call("getUserByEmail", `Failed to get the user with the email "${email}"`, (auth) =>
+        auth.getUserByEmail(email),
+      ),
+    createUser: (properties) =>
+      call("createUser", "Failed to create the user", (auth) => auth.createUser(properties)),
+    updateUser: (uid, properties) =>
+      call("updateUser", `Failed to update the user "${uid}"`, (auth) =>
+        auth.updateUser(uid, properties),
+      ),
+    deleteUser: (uid) =>
+      call("deleteUser", `Failed to delete the user "${uid}"`, (auth) => auth.deleteUser(uid)),
+  });
+});
+
+/**
+ * A layer that provides {@link Auth} for the {@link App.App} in context.
+ *
+ * @example Providing Auth
+ * ```ts
+ * import { Layer } from "effect";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ * import { Auth } from "@visiolab/effect-firebase-admin/auth";
+ *
+ * const AuthLive = Auth.layer.pipe(Layer.provide(App.layer()));
+ * ```
+ *
+ * @see {@link make} for why building the service cannot fail
+ * @see {@link App.layer} for the app it needs
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.1.0
+ */
+export const layer: Layer.Layer<Auth, never, App.App> = Layer.effect(Auth, make);

package/src/auth/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Firebase Authentication on the Admin SDK, as an Effect service.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ */
+export * as Auth from "./Auth.ts";

package/src/firestore/AdminFirestore.ts

@@ -0,0 +1,303 @@
+/**
+ * Firestore on the Firebase Admin SDK, for servers.
+ *
+ * {@link layer} provides one service under two keys: the portable
+ * {@link Firestore}, which code that runs on either SDK asks for, and
+ * {@link AdminFirestore}, which adds what only the Admin SDK can do. Both reach
+ * the same database.
+ *
+ * @example Reading and writing a document
+ * ```ts
+ * import { Effect, Layer, Schema } from "effect";
+ * import { Collection, Firestore, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ * import { AdminFirestore } from "@visiolab/effect-firebase-admin/firestore";
+ *
+ * class Post extends FirestoreModel.Class<Post>("Post")({
+ *   title: Schema.String,
+ * }) {}
+ *
+ * const Posts = Collection.make("posts", Post);
+ * const hello = Posts.doc(Posts.id.make("hello"));
+ *
+ * const program = Effect.gen(function* () {
+ *   const firestore = yield* Firestore.Firestore;
+ *   yield* firestore.setDoc(hello, { title: "Hello" });
+ *   return yield* firestore.getDoc(hello);
+ * });
+ *
+ * const FirestoreLive = AdminFirestore.layer().pipe(Layer.provide(App.layer()));
+ *
+ * program.pipe(Effect.provide(FirestoreLive));
+ * ```
+ *
+ * @see {@link ClientFirestore} for the same service on the client SDK, for browsers
+ *
+ * @stability unstable
+ * @since 0.2.0
+ */
+import { Context, Effect, Layer } from "effect";
+import { Firestore, type With } from "@visiolab/effect-firebase/firestore/Firestore";
+import type { Transaction, TransactionBase } from "@visiolab/effect-firebase/firestore/Firestore";
+import type * as Admin from "firebase-admin/firestore";
+import type * as App from "../app/App.ts";
+import * as internalFirestore from "./internal/firestore.ts";
+
+const TypeId = internalFirestore.TypeId;
+
+const TransactionTypeId = internalFirestore.TransactionTypeId;
+
+/**
+ * The portable {@link Firestore}, plus what only the Admin SDK can do.
+ *
+ * **When to use**
+ *
+ * Ask for it where code needs the Admin SDK: {@link AdminTransaction} reads of
+ * many documents, or the SDK itself through {@link AdminFirestore.instance}.
+ * Everywhere else ask for {@link Firestore}, so the code also runs on the
+ * client SDK.
+ *
+ * **Details**
+ *
+ * The service its key holds is also a {@link Firestore}, so it can be handed to
+ * portable code as it is. The type itself only extends {@link Firestore.With},
+ * so providing a {@link Firestore} alone, such as an in-memory fake, does not
+ * satisfy code that asks for it. A {@link Firestore.With.runTransaction} body
+ * finds its transaction both
+ * as {@link AdminTransaction} and as the portable
+ * {@link Firestore.Transaction}. They are the same transaction, so portable
+ * helpers and Admin-only ones can run in the same body.
+ *
+ * The Admin SDK cannot abort a request in flight, so interrupting a call does
+ * not stop it: the request still runs to completion.
+ *
+ * @see {@link Firestore.With} for each read and write it offers
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface AdminFirestore extends With<never, never, {}, AdminTransaction> {
+  readonly [TypeId]: typeof TypeId;
+
+  /**
+   * The Admin SDK's own `Firestore`, for the database the service was opened
+   * on.
+   *
+   * **When to use**
+   *
+   * Use for what this service does not wrap, such as queries, batched writes
+   * or `recursiveDelete`. Prefer the service's own methods where one exists.
+   *
+   * **Details**
+   *
+   * Calls through it skip the collection's model, take and return the SDK's
+   * own values, and throw the SDK's own errors. To write a model through it,
+   * encode with {@link FirestoreValue.toCodecFirestore} and map with
+   * {@link AdminFirestoreValue.toAdmin}.
+   *
+   * @see {@link AdminFirestoreValue} for mapping between the SDK's values and Firestore Values
+   */
+  readonly instance: Admin.Firestore;
+}
+
+/**
+ * A {@link Firestore.Transaction} that can also read every document in a
+ * collection or a Collection Group, which only the Admin SDK's transactions
+ * can.
+ *
+ * **When to use**
+ *
+ * Ask for it in a transaction body that reads many documents. A body that only
+ * reads single documents should ask for the portable
+ * {@link Firestore.Transaction}, so it also runs on the client SDK.
+ *
+ * **Details**
+ *
+ * A body run through {@link AdminFirestore} finds it next to
+ * {@link Firestore.Transaction}; they are the same transaction. The type
+ * extends {@link Firestore.TransactionBase}, not {@link Firestore.Transaction},
+ * and its key holds an `AdminTransaction & Transaction`. A body that asks for
+ * it and runs
+ * through the portable {@link Firestore} still needs it provided, so the
+ * compiler catches Admin-only code handed to portable code.
+ *
+ * The same rules hold as for {@link Firestore.Transaction}: a read of many is a
+ * read, so it comes before every write.
+ *
+ * @example Reading a collection in a transaction
+ * ```ts
+ * import { Effect, Schema } from "effect";
+ * import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { AdminFirestore } from "@visiolab/effect-firebase-admin/firestore";
+ *
+ * class Seat extends FirestoreModel.Class<Seat>("Seat")({
+ *   taken: Schema.Boolean,
+ * }) {}
+ *
+ * const Seats = Collection.make("seats", Seat);
+ *
+ * const takeAnySeat = Effect.gen(function* () {
+ *   const firestore = yield* AdminFirestore.AdminFirestore;
+ *   return yield* firestore.runTransaction(
+ *     Effect.gen(function* () {
+ *       const tx = yield* AdminFirestore.AdminTransaction;
+ *       const { docs } = yield* tx.getDocs(Seats.collection());
+ *       for (const seat of docs) {
+ *         if (!(yield* seat.data).taken) {
+ *           yield* tx.updateDoc(seat.ref, { taken: true });
+ *           return seat.id;
+ *         }
+ *       }
+ *       return undefined;
+ *     }),
+ *   );
+ * });
+ * ```
+ *
+ * @see {@link Firestore.Transaction} for the portable transaction, which reads one document at a time
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface AdminTransaction extends TransactionBase {
+  readonly [TransactionTypeId]: typeof TransactionTypeId;
+
+  /**
+   * Reads every document in a collection or a Collection Group as part of the
+   * transaction, as {@link Firestore.With.getDocs} does outside one.
+   *
+   * Every document it returns is locked for the rest of the transaction, so
+   * another write to one of them makes the transaction run again. A group
+   * read that fails with an {@link Firestore.UndefinedCollectionError} fails
+   * the body, which rolls the transaction back without running it again.
+   */
+  readonly getDocs: Firestore["getDocs"];
+}
+
+/**
+ * Service key for {@link AdminTransaction}. The transaction it holds is a
+ * {@link Firestore.Transaction} too.
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.2.0
+ */
+export const AdminTransaction = Context.Service<AdminTransaction, AdminTransaction & Transaction>(
+  "@visiolab/effect-firebase-admin/firestore/AdminFirestore/AdminTransaction",
+);
+
+/**
+ * Service key for {@link AdminFirestore}.
+ *
+ * @see {@link Firestore} for the portable key, which {@link layer} provides the same service under
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.2.0
+ */
+export const AdminFirestore = Context.Service<AdminFirestore, AdminFirestore & Firestore>(
+  "@visiolab/effect-firebase-admin/firestore/AdminFirestore",
+);
+
+/**
+ * How {@link layer} opens a database. Both are fixed once the database is open.
+ *
+ * There is no emulator option. The Admin SDK reads the emulator from the
+ * `FIRESTORE_EMULATOR_HOST` environment variable, which must be set before the
+ * database is opened and applies to every app in the process.
+ *
+ * @see {@link ClientFirestore.Options} for the client SDK's, which take the emulator per database
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface Options {
+  /**
+   * The database to open, where the project has more than its default one.
+   * Leave it out for the default database.
+   */
+  readonly databaseId?: string | undefined;
+  /**
+   * Talk HTTP/1.1 instead of gRPC until something needs gRPC.
+   *
+   * Use it where a process handles a request or two and exits, such as a
+   * function: it saves loading the gRPC libraries and opening a channel.
+   * Listening is the one thing that needs gRPC; the first listen loads it and
+   * the SDK stays on it.
+   */
+  readonly preferRest?: boolean | undefined;
+}
+
+/**
+ * Builds {@link AdminFirestore} on the {@link App.App} in context.
+ *
+ * **When to use**
+ *
+ * Use to build the service inside an effect of your own. Most programs provide
+ * it with {@link layer} instead, which also provides it as {@link Firestore}.
+ *
+ * **Details**
+ *
+ * Building the service cannot fail. Opening a database only throws for an app
+ * that was already deleted, something that is not an app, or a database already
+ * opened with other settings. All three are wiring mistakes, so they are
+ * defects, and a {@link Firestore.FirestoreError} only ever means that a call
+ * failed.
+ *
+ * @see {@link layer} for the same as a layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export const make: (
+  options?: Options,
+) => Effect.Effect<AdminFirestore & Firestore, never, App.App> = Effect.fn("AdminFirestore.make")(
+  function* (options?: Options) {
+    const firestore = yield* internalFirestore.openDatabase(options);
+    return internalFirestore.fromDatabase(firestore, AdminTransaction);
+  },
+);
+
+/** The one service, under both its own tag and the portable one. */
+const both = (service: AdminFirestore & Firestore) =>
+  Context.make(AdminFirestore, service).pipe(Context.add(Firestore, service));
+
+/**
+ * A layer that provides {@link AdminFirestore} for the {@link App.App} in
+ * context, and the same service as the portable {@link Firestore}.
+ *
+ * **When to use**
+ *
+ * Use on a server, or anywhere the Admin SDK runs. In a browser, use
+ * {@link ClientFirestore.layer} instead.
+ *
+ * **Details**
+ *
+ * With no options it opens the project's default database with the SDK's
+ * defaults.
+ *
+ * @example Providing Firestore against the emulator
+ * ```ts
+ * import { Layer } from "effect";
+ * import { App } from "@visiolab/effect-firebase-admin/app";
+ * import { AdminFirestore } from "@visiolab/effect-firebase-admin/firestore";
+ *
+ * // The Admin SDK reads FIRESTORE_EMULATOR_HOST, such as "127.0.0.1:8080".
+ * const FirestoreLive = AdminFirestore.layer({ preferRest: true }).pipe(
+ *   Layer.provide(App.layer({ projectId: "demo-project" })),
+ * );
+ * ```
+ *
+ * @see {@link make} for why building the service cannot fail
+ * @see {@link ClientFirestore.layer} for the client SDK's layer, for browsers
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.2.0
+ */
+export const layer = (options?: Options): Layer.Layer<AdminFirestore | Firestore, never, App.App> =>
+  Layer.effectContext(Effect.map(make(options), both));

package/src/firestore/AdminFirestoreValue.ts

@@ -0,0 +1,93 @@
+/**
+ * Maps between Firestore Values, the portable values a model encodes to, and
+ * the values the Admin SDK reads and writes.
+ *
+ * {@link AdminFirestore} applies it on every read and write. Use it directly to
+ * read or write a model through the Admin SDK itself, such as through
+ * {@link AdminFirestore.instance}.
+ *
+ * @example Writing a model through the Admin SDK
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FirestoreModel, FirestoreValue } from "@visiolab/effect-firebase/firestore";
+ * import { AdminFirestoreValue } from "@visiolab/effect-firebase-admin/firestore";
+ * import { type DocumentData, getFirestore } from "firebase-admin/firestore";
+ *
+ * class Post extends FirestoreModel.Class<Post>("Post")({
+ *   title: Schema.String,
+ * }) {}
+ *
+ * const firestore = getFirestore();
+ * const encoded = Schema.encodeSync(FirestoreValue.toCodecFirestore(Post.create))({
+ *   title: "Hello",
+ * });
+ * await firestore
+ *   .doc("posts/hello")
+ *   .set(AdminFirestoreValue.toAdmin(encoded, firestore) as DocumentData);
+ * ```
+ *
+ * @see {@link ClientFirestoreValue} for the client SDK's mapping
+ *
+ * @stability unstable
+ * @since 0.2.0
+ */
+import type { Result } from "effect";
+import type { FirestoreError } from "@visiolab/effect-firebase/firestore/Firestore";
+import type { FirestoreValue } from "@visiolab/effect-firebase/firestore/FirestoreValue";
+import type { Firestore } from "firebase-admin/firestore";
+import * as internal from "./internal/firestoreValue.ts";
+
+/**
+ * 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
+ */
+export const toAdmin: (value: FirestoreValue, firestore: Firestore) => unknown = internal.toAdmin;
+
+/**
+ * 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
+ */
+export const fromAdmin: (value: unknown) => Result.Result<FirestoreValue, FirestoreError> =
+  internal.fromAdmin;

package/src/firestore/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Firestore on the Firebase Admin SDK, for servers.
+ *
+ * @stability unstable
+ * @since 0.2.0
+ */
+export * as AdminFirestore from "./AdminFirestore.ts";
+/**
+ * Maps between Firestore Values and the values the Admin SDK reads and writes.
+ *
+ * @stability unstable
+ * @since 0.2.0
+ */
+export * as AdminFirestoreValue from "./AdminFirestoreValue.ts";