@visiolab/effect-firebase-functions 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,229 @@
-# Temporary Holding Version
+# @visiolab/effect-firebase-functions
 
-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.
+Deploys the Functions of [`@visiolab/effect-firebase`](https://github.com/VisioLab/effect-firebase/tree/main/packages/effect-firebase) as Cloud Functions for Firebase, with `firebase-functions`. A Function is a server function declared once by its name and what runs it. Callables are the kind of Function the client calls, with `CallableClient` from [`@visiolab/effect-firebase-client`](https://github.com/VisioLab/effect-firebase/tree/main/packages/client).
+
+```sh
+pnpm add effect @visiolab/effect-firebase @visiolab/effect-firebase-admin @visiolab/effect-firebase-functions firebase-admin firebase-functions
+```
+
+## Callable Functions
+
+Declare a Callable once, in code the server and the client share:
+
+```ts
+import { Schema } from "effect";
+import { Callable } from "@visiolab/effect-firebase/functions";
+
+export const Greet = Callable.make("greet", {
+  payload: { name: Schema.String },
+  success: Schema.String,
+});
+```
+
+Implement it as a Layer, and export it with `Functions.make`:
+
+```ts
+import { Effect } from "effect";
+import { Callable } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+import { Greet } from "./contract.ts";
+
+const GreetLive = Callable.toLayer(Greet, ({ name }) => Effect.succeed(`Hello, ${name}!`));
+
+export const { greet } = Functions.make(Greet, GreetLive, { region: "europe-west1" });
+```
+
+`Functions.make` dispatches on the Function's kind. For a Callable, the export is exactly what `onCall` returns, so plain `firebase deploy` deploys it, and the third argument is Firebase's `CallableOptions`, passed through unchanged.
+
+- The Layer is built on the first call, not at deploy or when the module loads. Every Layer is built through one memo map per process, so concurrent first calls share one build.
+- `minInstances` keeps an instance alive, but its Layer is still built on the first call.
+- Finalizers of the Layer don't run when the instance shuts down.
+- Give each export a Layer of its own where you can, so a cold instance builds only what its function needs.
+- Call `setGlobalOptions` before any function is defined, as Firebase requires.
+
+## Document Triggers
+
+A Document Trigger runs when a document of a collection changes. Declare it from a name and a `Collection` definition, implement it with `DocumentTrigger.toLayer`, and deploy it with `Functions.make`:
+
+```ts
+import { Effect } from "effect";
+import { DocumentTrigger } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+import { Posts } from "./collections.ts";
+
+const OnPostCreated = DocumentTrigger.created("onPostCreated", Posts);
+
+export const { onPostCreated } = Functions.make(
+  OnPostCreated,
+  DocumentTrigger.toLayer(OnPostCreated, (event) =>
+    Effect.gen(function* () {
+      const [authorId] = event.ref.ancestors;
+      const post = yield* event.snapshot.data;
+      yield* Effect.log(`${authorId} published ${post.title}`);
+    }),
+  ),
+  { retry: true },
+);
+```
+
+- There is one constructor per change: `created` and `deleted` hand over `event.snapshot` (on `deleted`, the document as it was just before), `updated` hands over `event.before` and `event.after`, both existing, and `written` runs on all three, with `before` missing on a create and `after` missing on a delete. Narrow a `written` side with `DocumentSnapshot.isExisting` or `isMissing`.
+- The trigger listens to the `(default)` database, at a path pattern derived from the collection: one wildcard per parent document and one for the document. The ids are on `event.ref`, typed.
+- `event.snapshot.data` decodes through the collection's model when it runs; `event.snapshot.raw` holds the stored Firestore Values. The same holds for each existing side of a change.
+- The options are the shared `firebase-functions` options plus `retry`.
+- Any failure fails the event: a typed error, a defect, an interrupt, or a Layer that fails to build. Its Cause is logged at Error in the event's span, and the function throws. Firebase then delivers the event again when `retry` is set, and drops it otherwise. The library adds no retry of its own. Events are delivered at least once: key idempotent work on `event.id`.
+- A Layer that fails to build is built again on the next event.
+- The Functions emulator never delivers a failed event again, even with `retry`, and replaces the worker whose function threw.
+- Add a trigger to a Function Group next to Callables to deploy it as `<group>-<name>` (see [Function Groups](#function-groups)).
+- Test a handler in process with `DocumentTrigger.serve`, and an event built with `DocumentTrigger.createdEvent`, `updatedEvent`, `deletedEvent` or `writtenEvent` from `DocumentSnapshot.existing` and `DocumentSnapshot.missing`.
+- The package takes `@visiolab/effect-firebase-admin` and `firebase-admin` as peer dependencies, to read event data as the Admin SDK reads do.
+
+## Function Groups
+
+Collect related Functions, of any kind, into a Function Group. Each member deploys under the group's name as a prefix:
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+
+const CreateUser = Callable.make("create", {
+  payload: { name: Schema.String },
+  success: Schema.String,
+});
+const DeleteUser = Callable.make("delete", { payload: { id: Schema.String } });
+
+class Users extends FunctionGroup.make("users").add(CreateUser, DeleteUser) {}
+
+const UsersLive = Layer.mergeAll(
+  Callable.toLayer(Users, "create", ({ name }) => Effect.succeed(name)),
+  Callable.toLayer(Users, "delete", () => Effect.void),
+);
+
+// Deploys `users-create` and `users-delete`.
+export const { users } = Functions.group(Users, UsersLive, {
+  delete: { region: "europe-west1" },
+});
+```
+
+A group can hold Callables and Document Triggers together, so you can group by domain rather than by kind:
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+import { Callable, DocumentTrigger, FunctionGroup } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+
+class Post extends FirestoreModel.Class<Post>("Post")({ title: Schema.String }) {}
+
+const PostsCollection = Collection.make("posts", Post);
+
+const Publish = Callable.make("publish", { payload: { id: Schema.String } });
+const OnCreated = DocumentTrigger.created("onCreated", PostsCollection);
+
+class Posts extends FunctionGroup.make("posts").add(Publish, OnCreated) {}
+
+// Deploys `posts-publish` and `posts-onCreated`.
+export const { posts } = Functions.group(
+  Posts,
+  Layer.mergeAll(
+    Callable.toLayer(Posts, "publish", () => Effect.void),
+    DocumentTrigger.toLayer(Posts, "onCreated", (event) => Effect.log(event.ref.id)),
+  ),
+  { publish: { cors: true }, onCreated: { retry: true } },
+);
+```
+
+- Implement a member with `Callable.toLayer(Users, "create", handler)` or `DocumentTrigger.toLayer(Posts, "onCreated", handler)`. A Layer from the Function on its own doesn't serve it in the group.
+- The options are a sparse map keyed by member name, each typed by the member's kind: `CallableOptions` for a Callable, and the shared options plus `retry` for a Document Trigger. The group has none of its own.
+- A Function can be in more than one group. Each group serves and implements it separately.
+- Names must be unique within a group. `.add` throws when a name is taken, so the clash fails when the module loads. The types don't catch it.
+- Build the client from the group, `CallableClient.make(Users)`. It has a function for each of the group's Callables, and none for its Document Triggers. A client built from the member on its own calls the unprefixed name and gets `not-found`.
+
+## Middleware and the Caller
+
+Requirements such as "the caller is signed in" are Callable Middleware on the contract. The built-in `Caller.Authenticated` provides the `Caller` and fails a signed-out call with `CallableError.Unauthenticated`, before the Payload is decoded:
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Callable, Caller } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+
+const WhoAmI = Callable.make("whoAmI", { success: Schema.String }).middleware(Caller.Authenticated);
+
+const WhoAmILive = Callable.toLayer(WhoAmI, () =>
+  Effect.map(Effect.service(Caller.Caller), ({ uid }) => uid),
+);
+
+// `Live` provides the handler and every middleware implementation.
+export const { whoAmI } = Functions.make(
+  WhoAmI,
+  Layer.merge(WhoAmILive, Caller.Authenticated.layer),
+);
+```
+
+- Declare a middleware of your own with `CallableMiddleware.Service`. Its implementation wraps the call and reads the portable `CallableRequest`: `auth`, `app`, the raw `data`, and `rawRequest`, the HTTP request as Effect's `HttpServerRequest`, with the caller's IP address as `remoteAddress`. Every call provides it, so the Layer you serve needn't, even when a handler or middleware reads it. Its body streams Firebase's buffered bytes without copying them.
+- The Firebase web SDK's `httpsCallable` can't send custom headers. A header of your own reaches `rawRequest` only from callers that don't use it, such as another server. Headers like `user-agent` and `accept-language` are there for every caller.
+- A middleware attached later wraps the ones attached before it.
+- The Payload is decoded inside the chain, so a middleware that catches every failure also catches a Payload that doesn't decode. The caller then no longer gets `invalid-argument`. Catch only the errors you mean to.
+- `Functions` provides no middleware itself, so a `Live` without an implementation is a type error.
+- Run a handler in process, with its chain and without the emulator, through `Callable.handler(WhoAmI)`. Pass a `rawRequest` built with `HttpServerRequest.fromWeb` to test a middleware that reads headers or the address; left out, it is a JSON `POST` of the Payload to `http://localhost/<deployed name>`.
+
+### Middleware in a group
+
+A Function Group carries no middleware. Attach a middleware to each member that needs it:
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Callable, FunctionGroup, Caller } from "@visiolab/effect-firebase/functions";
+import { Functions } from "@visiolab/effect-firebase-functions";
+
+const Me = Callable.make("me", { success: Schema.String }).middleware(Caller.Authenticated);
+
+class Accounts extends FunctionGroup.make("accounts").add(Me) {}
+
+export const { accounts } = Functions.group(
+  Accounts,
+  Layer.merge(
+    Callable.toLayer(Accounts, "me", () =>
+      Effect.map(Effect.service(Caller.Caller), ({ uid }) => uid),
+    ),
+    Caller.Authenticated.layer,
+  ),
+);
+```
+
+## Tracing
+
+Every call runs in a `kind: "server"` span named `CallableFunction.<deployed name>`, such as `CallableFunction.users-create`, with the attributes `rpc.system: "firebase_callable"`, `rpc.method`, `rpc.service` (the group, for a member) and `faas.name`. Spans are exported only when the Layer you export provides a `Tracer`, for example from `@effect/opentelemetry`:
+
+```ts
+export const { users } = Functions.group(Users, Layer.mergeAll(UsersLive, TracingLive));
+```
+
+- The span covers the middleware, decoding the Payload, the handler and encoding the answer. On the call that builds the Layer, it covers the build too, and spans opened during the build are its children.
+- Its parent is the trace context Firebase reads from the request (`X-Cloud-Trace-Context`, else `traceparent`), so it joins the platform's trace. In the emulator it is a root span.
+- `CallableClient` opens a `kind: "client"` span per call. It isn't linked to the server span: the two land in separate traces.
+- Neither span carries a uid. Add one where you want it with `Effect.annotateCurrentSpan("enduser.id", uid)`.
+- Every event of a Document Trigger runs in a `kind: "server"` span named `DocumentTrigger.<deployed name>`, such as `DocumentTrigger.onPostCreated`, with the attributes `faas.name` and `faas.trigger: "datasource"`. It covers converting the event, the handler and, on the event that builds the Layer, the build. Its parent is the trace context Firebase reads from the event's `traceparent`.
+
+## Logging
+
+Every call and every Document Trigger event logs through `CloudLogging.layer`, which writes each Effect log as one Cloud Logging JSON line, in the format of Firebase's own `logger`:
+
+- The trace, span id and sampled flag come from the current span, so concurrent calls and events on one instance each log under their own trace.
+- Trace and Debug are `DEBUG`, Info `INFO`, Warn `WARNING`, Error `ERROR` and Fatal `CRITICAL`. Error and Fatal go to `console.error`, the rest to `console.log`.
+- Log annotations become fields of the entry, other logged values go under `args` and log spans under `spans`.
+- A Cause is appended to `message` with its stacks, so defects and failed Layer builds reach Error Reporting.
+- Entries carry no uid. Add one where you want it with `Effect.annotateLogs({ uid })`.
+- The project comes from `GCLOUD_PROJECT`, else `GOOGLE_CLOUD_PROJECT`. With neither, entries carry no trace fields.
+- Logs written while the first call builds the Layer are held until the build is done, so they get the spans' final ids. Entries carry no timestamp of their own, so Cloud Logging stamps them with the time the build finished.
+- Provide a `Logger.layer` in the Layer you export to log differently.
+
+To log the same way outside a deployed Function, provide the layer yourself:
+
+```ts
+import { Effect } from "effect";
+import { CloudLogging } from "@visiolab/effect-firebase-functions/logger";
+
+const job = Effect.log("Cleaning up").pipe(Effect.provide(CloudLogging.layer));
+```

package/dist/Functions.d.mts

@@ -0,0 +1,339 @@
+import { Layer } from "effect";
+import * as Callable from "@visiolab/effect-firebase/functions/Callable";
+import * as Https from "firebase-functions/v2/https";
+import { CloudFunction } from "firebase-functions/v2";
+import * as DocumentTrigger from "@visiolab/effect-firebase/functions/DocumentTrigger";
+import * as Firestore from "firebase-functions/v2/firestore";
+import * as FirebaseFunction from "@visiolab/effect-firebase/functions/FirebaseFunction";
+import * as FunctionGroup from "@visiolab/effect-firebase/functions/FunctionGroup";
+declare namespace Functions_d_exports {
+  export { CallableExport, DocumentTriggerExport, DocumentTriggerOptions, Export, Exports, GroupExports, GroupOptions, GroupServices, Options, Services, group, make };
+}
+/**
+ * The value `onCall` returns for a Callable: what firebase-tools discovers and
+ * deploys.
+ *
+ * @see {@link Export} for the export of a Function of any kind
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type CallableExport = Https.CallableFunction<unknown, Promise<unknown>>;
+/**
+ * The value an `onDocument*` provider returns for a Document Trigger, by the
+ * change it runs on: what firebase-tools discovers and deploys.
+ *
+ * **Details**
+ *
+ * A `created` trigger is exported with `onDocumentCreated`, a `deleted` one
+ * with `onDocumentDeleted`, an `updated` one with `onDocumentUpdated` and a
+ * `written` one with `onDocumentWritten`. The type is the `CloudFunction` of
+ * the event that provider hands over.
+ *
+ * @see {@link Export} for the export of a Function of any kind
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type DocumentTriggerExport<T extends DocumentTrigger.Any> = CloudFunction<Firestore.FirestoreEvent<DocumentTriggerEventData[T["event"]]>>;
+/**
+ * The data of the event each `onDocument*` provider hands over, by the change
+ * it runs on.
+ */
+interface DocumentTriggerEventData {
+  readonly created: Firestore.QueryDocumentSnapshot | undefined;
+  readonly deleted: Firestore.QueryDocumentSnapshot | undefined;
+  readonly updated: Firestore.Change<Firestore.QueryDocumentSnapshot> | undefined;
+  readonly written: Firestore.Change<Firestore.DocumentSnapshot> | undefined;
+}
+/**
+ * The deploy options of a Document Trigger: Firebase's `DocumentOptions`
+ * without what the library derives from the trigger. That leaves the options
+ * every Function shares, such as `region`, `memory` and `timeoutSeconds`,
+ * plus `retry`.
+ *
+ * **Details**
+ *
+ * The `document` path pattern comes from the trigger's collection, and the
+ * database is always `(default)`, the one `Firestore` reads and writes, so
+ * `document`, `database` and `namespace` are left out, as are the event
+ * filter options.
+ *
+ * With `retry: true`, Firebase delivers a failed event again until it
+ * succeeds or its retry window ends. Without it, a failed event is dropped.
+ * The library adds no retry of its own.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type DocumentTriggerOptions = Omit<Firestore.DocumentOptions, "document" | "database" | "namespace" | "eventType" | "eventFilters" | "eventFilterPathPatterns" | "channel">;
+/**
+ * The export of a Function, by its kind: a {@link CallableExport} for a
+ * Callable, a {@link DocumentTriggerExport} for a Document Trigger.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Export<F extends FirebaseFunction.Any> = F extends Callable.Any ? CallableExport : F extends DocumentTrigger.Any ? DocumentTriggerExport<F> : never;
+/**
+ * The deploy options of a Function, by its kind: Firebase's `CallableOptions`
+ * for a Callable, passed to `onCall` unchanged, and
+ * {@link DocumentTriggerOptions} for a Document Trigger.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Options<F extends FirebaseFunction.Any> = F extends Callable.Any ? Https.CallableOptions : F extends DocumentTrigger.Any ? DocumentTriggerOptions : never;
+/**
+ * What serving a Function under the handler key `H` requires, by its kind.
+ * For a Callable: its handler, the implementation of each of its middleware,
+ * and what its middleware chain still requires. For a Document Trigger: its
+ * handler.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Services<F extends FirebaseFunction.Any, H> = F extends Callable.Any ? Callable.ChainServices<F, H> : F extends DocumentTrigger.Any ? H : never;
+/**
+ * What serving every member of a {@link FunctionGroup.FunctionGroup}
+ * requires: what each member requires, by its kind, under its handler key in
+ * the group.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type GroupServices<G extends FunctionGroup.Any> = FunctionGroup.Names<G> extends (infer Name) ? Name extends string ? Services<FunctionGroup.Member<G, Name>, FirebaseFunction.Handler<G["identifier"], Name>> : never : never;
+/**
+ * The exports of {@link make}: one export under the Function's name.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type Exports<F extends FirebaseFunction.Any> = { readonly [K in F["name"]]: Export<F>; };
+/**
+ * The exports of {@link group}: one export per member, keyed by the member's
+ * name, under the group's name.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type GroupExports<G extends FunctionGroup.Any> = { readonly [K in G["identifier"]]: { readonly [N in FunctionGroup.Names<G>]: Export<FunctionGroup.Member<G, N>>; }; };
+/**
+ * The options of {@link group}: each member's {@link Options}, typed by its
+ * kind and keyed by its name. Members left out get none.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export type GroupOptions<G extends FunctionGroup.Any> = { readonly [N in FunctionGroup.Names<G>]?: Options<FunctionGroup.Member<G, N>>; };
+/**
+ * Deploys a Function in no group, whatever its kind.
+ *
+ * **When to use**
+ *
+ * Use to export a Function in no group. Destructure the result into the
+ * module's exports, so the export's name is the Function's.
+ *
+ * **Details**
+ *
+ * `live` must provide what the Function's kind needs and leave nothing
+ * required. It may provide more. Give each export a Layer of its own where you
+ * can: a cold instance then builds only what its own function needs.
+ *
+ * `options` are typed by the Function's kind (see {@link Options}).
+ *
+ * For a Callable, `live` provides its handler, from `Callable.toLayer`, and
+ * the implementation of each of its middleware, such as
+ * `Caller.Authenticated.layer`. `Functions` provides no middleware itself.
+ * `options` is Firebase's `CallableOptions`, and the export is exactly what
+ * `onCall` returns, so its `__endpoint` and `run` work as for any `onCall`
+ * function.
+ *
+ * For a Document Trigger, `live` provides its handler, from
+ * `DocumentTrigger.toLayer`. `options` are {@link DocumentTriggerOptions}:
+ * the shared options plus `retry`. The export is what the provider of the
+ * trigger's change (`onDocumentCreated`, `onDocumentUpdated`,
+ * `onDocumentDeleted` or `onDocumentWritten`) returns for the `(default)`
+ * database and the path pattern of the trigger's collection. Each event is
+ * converted into the trigger's event, its data read into Firestore Values as
+ * a read does, a side that doesn't exist as a `Missing` snapshot, and run
+ * through `DocumentTrigger.serve`, in a `kind: "server"` span named
+ * `DocumentTrigger.<deployed name>` with `faas.name` and
+ * `faas.trigger: "datasource"`, logging through `CloudLogging.layer`. Any
+ * failure, whether a typed error, a defect, an interrupt or a Layer that
+ * fails to build, is logged at Error in that span and makes the function
+ * throw, so Firebase delivers the event again when `retry` is set. A Layer
+ * that failed to build is built again on the next event.
+ *
+ * Each call runs the Callable's middleware chain, the one `Callable.handler`
+ * runs, with Firebase's request provided as the portable `CallableRequest`.
+ * Its `rawRequest` is Firebase's Express request as Effect's
+ * `HttpServerRequest`, with the caller's IP address as `remoteAddress`. Its
+ * body streams Firebase's buffered bytes without copying them. The Payload is
+ * decoded inside the chain, after the middleware.
+ *
+ * A failed call answers with an `HttpsError`:
+ *
+ * - A declared error, or an error of a middleware, is sent with its schema's
+ *   code, the error's `message` (else its `_tag`) and the error encoded with
+ *   `Schema.toCodecJson` as `details`, so the client decodes it back into its
+ *   class. A middleware that rejects the call answers before the Payload is
+ *   decoded.
+ * - A Payload that doesn't decode is answered with `invalid-argument`, a
+ *   generic message and no details. It is logged at Debug.
+ * - A defect, or a success or error value that doesn't encode, is answered
+ *   with a bare `internal`. Its Cause is logged at Error, with the logger of
+ *   `live` if it provides one.
+ * - A Layer that fails to build answers the call with a bare `internal` and
+ *   is logged at Error. The next call builds it again.
+ * - An interrupt of the handler is answered with `unavailable`. When the
+ *   client disconnects, the handler is interrupted and the call is answered
+ *   with `cancelled`, as far as the platform reports the disconnect.
+ *
+ * @example Exporting a Callable
+ * ```ts
+ * import { Effect } from "effect";
+ * import { Callable } from "@visiolab/effect-firebase/functions";
+ * import { Functions } from "@visiolab/effect-firebase-functions";
+ *
+ * const Ping = Callable.make("ping");
+ *
+ * export const { ping } = Functions.make(Ping, Callable.toLayer(Ping, () => Effect.void));
+ * ```
+ *
+ * @example Exporting a Document Trigger
+ * ```ts
+ * import { Effect, Schema } from "effect";
+ * import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { DocumentTrigger } from "@visiolab/effect-firebase/functions";
+ * import { Functions } from "@visiolab/effect-firebase-functions";
+ *
+ * class Post extends FirestoreModel.Class<Post>("Post")({ title: Schema.String }) {}
+ *
+ * const OnPostCreated = DocumentTrigger.created("onPostCreated", Collection.make("posts", Post));
+ *
+ * export const { onPostCreated } = Functions.make(
+ *   OnPostCreated,
+ *   DocumentTrigger.toLayer(OnPostCreated, (event) =>
+ *     Effect.flatMap(event.snapshot.data, (post) => Effect.log(`New post: ${post.title}`)),
+ *   ),
+ *   { retry: true },
+ * );
+ * ```
+ *
+ * @see {@link group} for deploying the members of a Function Group
+ * @see {@link Callable.serve} for serving a Callable from a transport of your own
+ * @see {@link Callable.handler} for running a Callable's handler in process
+ * @see {@link DocumentTrigger.serve} for running a Document Trigger's event in process
+ * @see {@link CallableClient.make} for calling a Callable from the client
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const make: <F extends FirebaseFunction.Any, E>(fn: F, live: Layer.Layer<Services<F, FirebaseFunction.HandlerFor<F>>, E>, options?: Options<F>) => Exports<F>;
+/**
+ * Deploys the members of a Function Group, each as a function of its own,
+ * whatever their kinds.
+ *
+ * **When to use**
+ *
+ * Use to export a Function Group. Destructure the result into the module's
+ * exports, so `export const { users } = Functions.group(Users, Live)` deploys
+ * `users-create`, `users-delete` and so on.
+ *
+ * **Details**
+ *
+ * `live` must provide what every member needs, by its kind, and leave nothing
+ * required. For a Callable member, that is its handler, from
+ * `Callable.toLayer(Users, name, handler)`, and the implementation of each of
+ * its middleware. A handler from `Callable.toLayer` of the Callable on its
+ * own doesn't serve it in the group. For a Document Trigger member, that is
+ * its handler, from `DocumentTrigger.toLayer(Posts, name, handler)`. `live`
+ * may provide more, such as the handlers of other groups.
+ *
+ * Each member is its own function, with a worker of its own. A worker builds
+ * `live` on the first call to its own function, and never for another
+ * member's. One `live` per group is fine. Split it when members need very
+ * different services, so a cold instance builds only what its function needs.
+ *
+ * `options` holds each member's {@link Options}, keyed by the member's name
+ * and typed by its kind. A Callable member's are Firebase's `CallableOptions`,
+ * passed to its `onCall` unchanged. A Document Trigger member's are
+ * {@link DocumentTriggerOptions}: the shared options plus `retry`. The group
+ * has no options of its own: set those once with `setGlobalOptions`.
+ *
+ * Each export is what the member's kind deploys, and fails as one from
+ * {@link make} does.
+ *
+ * @example Exporting a Function Group
+ * ```ts
+ * import { Effect, Layer, Schema } from "effect";
+ * import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+ * import { Functions } from "@visiolab/effect-firebase-functions";
+ *
+ * const CreateUser = Callable.make("create", {
+ *   payload: { name: Schema.String },
+ *   success: Schema.String,
+ * });
+ * const DeleteUser = Callable.make("delete", { payload: { id: Schema.String } });
+ *
+ * class Users extends FunctionGroup.make("users").add(CreateUser, DeleteUser) {}
+ *
+ * const UsersLive = Layer.mergeAll(
+ *   Callable.toLayer(Users, "create", ({ name }) => Effect.succeed(name)),
+ *   Callable.toLayer(Users, "delete", () => Effect.void),
+ * );
+ *
+ * // Deploys `users-create` and `users-delete`.
+ * export const { users } = Functions.group(Users, UsersLive, {
+ *   delete: { region: "europe-west1" },
+ * });
+ * ```
+ *
+ * @example Exporting a group of a Callable and a Document Trigger
+ * ```ts
+ * import { Effect, Layer, Schema } from "effect";
+ * import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { Callable, DocumentTrigger, FunctionGroup } from "@visiolab/effect-firebase/functions";
+ * import { Functions } from "@visiolab/effect-firebase-functions";
+ *
+ * class Post extends FirestoreModel.Class<Post>("Post")({ title: Schema.String }) {}
+ *
+ * const Publish = Callable.make("publish", { payload: { id: Schema.String } });
+ * const OnCreated = DocumentTrigger.created("onCreated", Collection.make("posts", Post));
+ *
+ * class Posts extends FunctionGroup.make("posts").add(Publish, OnCreated) {}
+ *
+ * // Deploys `posts-publish` and `posts-onCreated`.
+ * export const { posts } = Functions.group(
+ *   Posts,
+ *   Layer.mergeAll(
+ *     Callable.toLayer(Posts, "publish", () => Effect.void),
+ *     DocumentTrigger.toLayer(Posts, "onCreated", (event) => Effect.log(event.ref.id)),
+ *   ),
+ *   { publish: { cors: true }, onCreated: { retry: true } },
+ * );
+ * ```
+ *
+ * @see {@link make} for deploying a Function in no group
+ * @see {@link FunctionGroup.make} for declaring the group
+ * @see {@link CallableClient.make} for calling the group's Callables from the client
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const group: <G extends FunctionGroup.Any, E>(group: G, live: Layer.Layer<GroupServices<G>, E>, options?: GroupOptions<G>) => GroupExports<G>;
+export { Functions_d_exports };
+//# sourceMappingURL=Functions.d.mts.map