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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VisioLab GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# @visiolab/effect-firebase-admin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The [`@visiolab/effect-firebase`](https://github.com/VisioLab/effect-firebase/tree/main/packages/effect-firebase) services on the Firebase Admin SDK (`firebase-admin`), for servers. In a browser, use [`@visiolab/effect-firebase-client`](https://github.com/VisioLab/effect-firebase/tree/main/packages/client) instead.
+
+```sh
+pnpm add effect @visiolab/effect-firebase @visiolab/effect-firebase-admin firebase-admin
+```
+
+## App
+
+`App` is the Admin SDK app as an Effect service. Every other service in this package is built on it.
+
+`App.layer` initializes the app when the layer is built and deletes it when the layer's scope closes. It takes the arguments of `initializeApp(options, name)`. With no arguments, the Admin SDK initializes the app from `FIREBASE_CONFIG` and application default credentials:
+
+```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()));
+```
+
+An app already registered under the same name is not deleted when the scope closes. The Admin SDK only hands that app back when the request matches how it was created, though: it rejects auto-init against explicit options, and rejects reuse outright when either side carries a credential or an `httpAgent`. To use an app the host initialized, provide it directly:
+
+```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());
+```
+
+## Firestore
+
+`AdminFirestore.layer` provides one service under two keys: the portable `Firestore`, which code that runs on either SDK asks for, and `AdminFirestore`, which adds what only the Admin SDK can do. Both reach the same database:
+
+```ts
+import { Layer } from "effect";
+import { App } from "@visiolab/effect-firebase-admin/app";
+import { AdminFirestore } from "@visiolab/effect-firebase-admin/firestore";
+
+const FirestoreLive = AdminFirestore.layer().pipe(Layer.provide(App.layer()));
+```
+
+Where it differs from the client SDK's:
+
+- **The emulator comes from the environment.** The Admin SDK reads `FIRESTORE_EMULATOR_HOST`, which must be set before the database is opened and applies to every app in the process.
+- **Transactions can read many documents.** A transaction body that asks for `AdminFirestore.AdminTransaction` can `getDocs` a collection or a Collection Group.
+- **`preferRest`** talks HTTP/1.1 instead of gRPC until something needs gRPC, which saves start-up time in short-lived processes.
+
+`AdminFirestore.instance` is the Admin SDK's own `Firestore`, for what the service does not wrap. `AdminFirestoreValue` maps between Firestore Values and the Admin SDK's values, to read or write a model through it.
+
+## Auth
+
+`Auth.layer` provides Firebase Authentication for the app in context. It wraps the calls server code uses most, such as `verifyIdToken` and the user management calls. Each fails with an `AuthError` that carries the SDK's `code`, such as `auth/user-not-found`. `Auth.use` reaches the rest of the Admin SDK:
+
+```ts
+import { Effect, Layer } from "effect";
+import { App } from "@visiolab/effect-firebase-admin/app";
+import { Auth } from "@visiolab/effect-firebase-admin/auth";
+
+const makeAdmin = (idToken: string) =>
+  Effect.gen(function* () {
+    const auth = yield* Auth.Auth;
+    const { uid } = yield* auth.verifyIdToken(idToken, true);
+    yield* auth.use((sdk) => sdk.setCustomUserClaims(uid, { admin: true }));
+  });
+
+const AuthLive = Auth.layer.pipe(Layer.provide(App.layer()));
+```

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll };

package/dist/app/App.d.mts

@@ -0,0 +1,115 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Admin from "firebase-admin/app";
+declare namespace App_d_exports {
+  export { App, AppError, layer, make };
+}
+/**
+ * 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 declare const App: Context.Service<App, App>;
+declare const AppError_base: Schema.Class<AppError, Schema.TaggedStruct<"AppError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * 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 declare class AppError extends AppError_base {}
+/**
+ * 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 declare const make: (options?: Admin.AppOptions | undefined, name?: string | undefined) => Effect.Effect<App, AppError, import("effect/Scope").Scope>;
+/**
+ * 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 declare const layer: (options?: Admin.AppOptions, name?: string) => Layer.Layer<App, AppError>;
+export { App_d_exports };
+//# sourceMappingURL=App.d.mts.map

package/dist/app/App.mjs

@@ -0,0 +1,145 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { initialize, release } from "./internal/app.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+// src/app/App.ts
+/**
+* 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
+*/
+var App_exports = /* @__PURE__ */ __exportAll({
+	App: () => App,
+	AppError: () => AppError,
+	layer: () => layer,
+	make: () => make
+});
+/**
+* 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
+*/
+const App = Context.Service("@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
+*/
+var AppError = class extends Schema.TaggedError()("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
+*/
+const make = Effect.fn("App.make")(function* (options, name) {
+	const { app } = yield* Effect.acquireRelease(Effect.try({
+		try: () => initialize(options, name),
+		catch: (cause) => new AppError({
+			message: "Failed to initialize the Firebase Admin SDK app",
+			cause
+		})
+	}), 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
+*/
+const layer = (options, name) => Layer.effect(App, make(options, name));
+export { App, AppError, App_exports, layer, make };
+
+//# sourceMappingURL=App.mjs.map

package/dist/app/App.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"App.mjs","names":["internalApp.initialize","internalApp.release"],"sources":["../../src/app/App.ts"],"sourcesContent":["/**\n * The Firebase Admin SDK app as an Effect service.\n *\n * Every other service in this package, such as {@link Auth.Auth} and\n * {@link AdminFirestore.AdminFirestore}, is built on the {@link App} in\n * context. Provide it with {@link layer}, or hand it an app the host already\n * initialized.\n *\n * @example Initializing the app for a program\n * ```ts\n * import { Effect } from \"effect\";\n * import { App } from \"@visiolab/effect-firebase-admin/app\";\n *\n * const program = Effect.gen(function* () {\n *   const app = yield* App.App;\n *   yield* Effect.log(`Running against ${app.name}`);\n * });\n *\n * program.pipe(Effect.provide(App.layer()));\n * ```\n *\n * @see [Add the Firebase Admin SDK to your server](https://firebase.google.com/docs/admin/setup)\n *\n * @stability unstable\n * @since 0.1.0\n */\nimport { Context, Effect, Layer, Schema } from \"effect\";\nimport type * as Admin from \"firebase-admin/app\";\n// Only the module's documentation links to these.\n// oxlint-disable-next-line no-unused-vars\nimport type * as Auth from \"../auth/Auth.ts\";\n// oxlint-disable-next-line no-unused-vars\nimport type * as AdminFirestore from \"../firestore/AdminFirestore.ts\";\nimport * as internalApp from \"./internal/app.ts\";\n\n/**\n * A Firebase Admin SDK app: the SDK's own `App`.\n *\n * @stability unstable\n * @category models\n * @since 0.1.0\n */\nexport interface App extends Admin.App {}\n\n/**\n * Service key for the Firebase Admin SDK app.\n *\n * **When to use**\n *\n * Use to provide an app the host already initialized, such as one from\n * `getApp()`, with `Layer.succeed`. Nothing deletes an app provided this way.\n *\n * @example Providing an app the host initialized\n * ```ts\n * import { Layer } from \"effect\";\n * import { getApp } from \"firebase-admin/app\";\n * import { App } from \"@visiolab/effect-firebase-admin/app\";\n *\n * const AppLive = Layer.succeed(App.App, getApp());\n * ```\n *\n * @see {@link layer} for initializing the app for the lifetime of a layer\n *\n * @stability unstable\n * @category services\n * @since 0.1.0\n */\nexport const App = Context.Service<App>(\"@visiolab/effect-firebase-admin/app/App\");\n\n/**\n * Fails {@link make} and {@link layer} when the Admin SDK refuses to initialize\n * the app, with what it threw as the `cause`.\n *\n * @stability unstable\n * @category errors\n * @since 0.1.0\n */\nexport class AppError extends Schema.TaggedError<AppError, { readonly brand: unique symbol }>()(\n  \"AppError\",\n  {\n    message: Schema.String,\n    cause: Schema.optional(Schema.Defect()),\n  },\n) {}\n\n/**\n * Initializes a Firebase Admin SDK app, and deletes it again when the\n * surrounding scope closes.\n *\n * **When to use**\n *\n * Use to build the app inside an effect of your own. Most programs provide it\n * with {@link layer} instead.\n *\n * **Details**\n *\n * Takes the arguments of `initializeApp(options, name)`. With no options, the\n * Admin SDK initializes the app from the `FIREBASE_CONFIG` environment variable\n * and application default credentials.\n *\n * An app already registered under the same name is not deleted when the scope\n * closes. The Admin SDK only hands back that app when the request matches how\n * it was created: it rejects auto-init against explicit options, and rejects\n * reuse outright when either side carries a credential or an `httpAgent`. To\n * pick up an app the host initialized, provide `getApp()` as {@link App}.\n *\n * Fails with an {@link AppError} when the Admin SDK refuses to initialize the\n * app. A failure to delete the app is logged as a warning, not raised.\n *\n * @see {@link layer} for the same as a layer\n *\n * @stability unstable\n * @category constructors\n * @since 0.1.0\n */\nexport const make = Effect.fn(\"App.make\")(function* (options?: Admin.AppOptions, name?: string) {\n  const { app } = yield* Effect.acquireRelease(\n    Effect.try({\n      try: () => internalApp.initialize(options, name),\n      catch: (cause) =>\n        new AppError({ message: \"Failed to initialize the Firebase Admin SDK app\", cause }),\n    }),\n    internalApp.release,\n  );\n  return app;\n});\n\n/**\n * A layer that initializes a Firebase Admin SDK app for the lifetime of the\n * layer.\n *\n * **When to use**\n *\n * Use when this program owns the app. Where the host has already initialized\n * one, provide that app as {@link App} instead.\n *\n * **Details**\n *\n * Takes the arguments of `initializeApp(options, name)`. With no options, the\n * Admin SDK initializes the app from the `FIREBASE_CONFIG` environment variable\n * and application default credentials.\n *\n * @example Initializing a named app with explicit options\n * ```ts\n * import { App } from \"@visiolab/effect-firebase-admin/app\";\n *\n * const AppLive = App.layer({ projectId: \"my-project\" }, \"secondary\");\n * ```\n *\n * @see {@link make} for how the app is initialized and torn down\n * @see {@link App} for providing an app the host initialized\n *\n * @stability unstable\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (options?: Admin.AppOptions, name?: string): Layer.Layer<App, AppError> =>\n  Layer.effect(App, make(options, name));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,MAAa,MAAM,QAAQ,QAAa,yCAAyC;;;;;;;;;AAUjF,IAAa,WAAb,cAA8B,OAAO,YAAyD,CAAC,CAC7F,YACA;CACE,SAAS,OAAO;CAChB,OAAO,OAAO,SAAS,OAAO,OAAO,CAAC;AACxC,CACF,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCH,MAAa,OAAO,OAAO,GAAG,UAAU,CAAC,CAAC,WAAW,SAA4B,MAAe;CAC9F,MAAM,EAAE,QAAQ,OAAO,OAAO,eAC5B,OAAO,IAAI;EACT,WAAWA,WAAuB,SAAS,IAAI;EAC/C,QAAQ,UACN,IAAI,SAAS;GAAE,SAAS;GAAmD;EAAM,CAAC;CACtF,CAAC,GACDC,OACF;CACA,OAAO;AACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BD,MAAa,SAAS,SAA4B,SAChD,MAAM,OAAO,KAAK,KAAK,SAAS,IAAI,CAAC"}

package/dist/app/index.d.mts

@@ -0,0 +1,2 @@
+import { App_d_exports } from "./App.mjs";
+export { App_d_exports as App };

package/dist/app/index.mjs

@@ -0,0 +1 @@
+export { App_exports as App } from "./App.mjs";

package/dist/app/internal/app.mjs

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { defaultAppName } from "@visiolab/effect-firebase/app/App";
+import * as Admin from "firebase-admin/app";
+// src/app/internal/app.ts
+/** @internal */
+const initialize = (options, name) => {
+	const owned = !Admin.getApps().some((app) => app.name === (name ?? defaultAppName));
+	return {
+		app: Admin.initializeApp(options, name),
+		owned
+	};
+};
+/** @internal */
+const release = ({ app, owned }) => owned ? Effect.tryPromise(() => Admin.deleteApp(app)).pipe(Effect.ignore({
+	log: "Warn",
+	message: `Failed to delete the Firebase Admin SDK app "${app.name}"`
+})) : Effect.void;
+export { initialize, release };
+
+//# sourceMappingURL=app.mjs.map

package/dist/app/internal/app.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.mjs","names":[],"sources":["../../../src/app/internal/app.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { defaultAppName } from \"@visiolab/effect-firebase/app/App\";\nimport * as Admin from \"firebase-admin/app\";\nimport type * as App from \"../App.ts\";\n\n/**\n * The app together with whether we are the ones who initialized it.\n *\n * @internal\n */\nexport interface Initialized {\n  readonly app: App.App;\n  readonly owned: boolean;\n}\n\n/** @internal */\nexport const initialize = (options?: Admin.AppOptions, name?: string): Initialized => {\n  // An app that is already registered under this name was initialized by\n  // somebody else - typically the hosting runtime - so ending its lifecycle is\n  // not ours to do. `initializeApp` still throws when that app was configured\n  // differently, so conflicting configuration is not swallowed here.\n  const owned = !Admin.getApps().some((app) => app.name === (name ?? defaultAppName));\n  return { app: Admin.initializeApp(options, name), owned };\n};\n\n/** @internal */\nexport const release = ({ app, owned }: Initialized): Effect.Effect<void> =>\n  owned\n    ? Effect.tryPromise(() => Admin.deleteApp(app)).pipe(\n        Effect.ignore({\n          log: \"Warn\",\n          message: `Failed to delete the Firebase Admin SDK app \"${app.name}\"`,\n        }),\n      )\n    : Effect.void;\n"],"mappings":";;;;;AAgBA,MAAa,cAAc,SAA4B,SAA+B;CAKpF,MAAM,QAAQ,CAAC,MAAM,QAAQ,CAAC,CAAC,MAAM,QAAQ,IAAI,UAAU,QAAQ,eAAe;CAClF,OAAO;EAAE,KAAK,MAAM,cAAc,SAAS,IAAI;EAAG;CAAM;AAC1D;;AAGA,MAAa,WAAW,EAAE,KAAK,YAC7B,QACI,OAAO,iBAAiB,MAAM,UAAU,GAAG,CAAC,CAAC,CAAC,KAC5C,OAAO,OAAO;CACZ,KAAK;CACL,SAAS,gDAAgD,IAAI,KAAK;AACpE,CAAC,CACH,IACA,OAAO"}

package/dist/auth/Auth.d.mts

@@ -0,0 +1,167 @@
+import { App } from "../app/App.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Admin from "firebase-admin/auth";
+declare namespace Auth_d_exports {
+  export { Auth, AuthError, layer, make };
+}
+declare const AuthError_base: Schema.Class<AuthError, Schema.TaggedStruct<"AuthError", {
+  readonly message: Schema.String;
+  /** The `service/string-code` the Admin SDK reported, such as `auth/user-not-found`. */
+  readonly code: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * 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 declare class AuthError extends AuthError_base {}
+/**
+ * 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 declare const Auth: Context.Service<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 declare const make: Effect.Effect<Auth, never, App>;
+/**
+ * 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 declare const layer: Layer.Layer<Auth, never, App>;
+export { Auth_d_exports };
+//# sourceMappingURL=Auth.d.mts.map