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

package/dist/functions/CallableClient.mjs

@@ -0,0 +1,215 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { ClientFunctions } from "./ClientFunctions.mjs";
+import { Effect, Schema } from "effect";
+import * as Callable from "@visiolab/effect-firebase/functions/Callable";
+import * as CallableError from "@visiolab/effect-firebase/functions/CallableError";
+import * as FunctionGroup from "@visiolab/effect-firebase/functions/FunctionGroup";
+import * as Sdk from "firebase/functions";
+// src/functions/CallableClient.ts
+/**
+* Callable Clients: call the Callables a server serves, with the Payload, the
+* success value and the errors typed by their contract.
+*
+* A client calls through the {@link ClientFunctions.ClientFunctions} in
+* context, so the region and the emulator are set once, where that is
+* provided.
+*
+* @example Calling a Callable
+* ```ts
+* import { Effect, Layer, Schema } from "effect";
+* import { Callable } from "@visiolab/effect-firebase/functions";
+* import { App } from "@visiolab/effect-firebase-client/app";
+* import { CallableClient, ClientFunctions } from "@visiolab/effect-firebase-client/functions";
+*
+* const Greet = Callable.make("greet", {
+*   payload: { name: Schema.String },
+*   success: Schema.String,
+* });
+*
+* const program = Effect.gen(function* () {
+*   const { greet } = yield* CallableClient.make(Greet);
+*   const message = yield* greet({ name: "Ada" });
+*   yield* Effect.log(message);
+* });
+*
+* const FunctionsLive = ClientFunctions.layer().pipe(
+*   Layer.provide(App.layer({ apiKey: "<api key>", projectId: "my-project", appId: "<app id>" })),
+* );
+*
+* program.pipe(Effect.provide(FunctionsLive));
+* ```
+*
+* @stability unstable
+* @since 0.3.0
+*/
+var CallableClient_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/** The ` [<status>]` the SDK appends to the message of an error built from an answer. */
+const statusSuffix = / \[(\d+)\]$/;
+/**
+* The messages of the SDK's errors for an answer it can't read: not a JSON
+* object, or one without `data` or `error`.
+*/
+const malformedAnswer = /Response is (?:not valid JSON object|missing data field)\.$/;
+/**
+* The client function of `callable`, served as `deployment`. `errors` are the
+* schemas of every error it can be answered with, its middleware's included.
+*/
+const method = (functions, callable, deployment, errors) => {
+	const deployedName = deployment.name;
+	const span = {
+		kind: "client",
+		attributes: deployment.attributes
+	};
+	const call = Sdk.httpsCallable(functions, deployedName);
+	const encode = Schema.encodeUnknownEffect(Schema.toCodecJson(callable.payload));
+	const decode = Schema.decodeUnknownEffect(Schema.toCodecJson(callable.success));
+	const fail = (reason) => new CallableError.CallableError({
+		callable: deployedName,
+		reason
+	});
+	const run = Effect.fn(`CallableClient.${deployedName}`, span)(function* (payload) {
+		const data = yield* encode(payload).pipe(Effect.mapError((cause) => fail(new CallableError.EncodeError({ cause }))));
+		const result = yield* Effect.tryPromise({
+			try: () => call(data),
+			catch: (error) => error
+		}).pipe(Effect.catch(decodeFailure));
+		return yield* decode(result.data).pipe(Effect.mapError((cause) => fail(new CallableError.DecodeError({ cause }))));
+	});
+	/**
+	* Turns what the SDK threw into the declared error it carries, or into a
+	* `CallableError`.
+	*/
+	const decodeFailure = (error) => {
+		if (!(error instanceof Sdk.FunctionsError)) return Effect.fail(fail(new CallableError.TransportError({ cause: error })));
+		const status = statusSuffix.exec(error.message)?.[1];
+		if (status === void 0 || status === "0") {
+			if (malformedAnswer.test(error.message)) return Effect.fail(fail(new CallableError.DecodeError({ cause: error })));
+			return Effect.fail(fail(new CallableError.TransportError({ cause: error })));
+		}
+		const code = error.code.replace(/^functions\//, "");
+		const candidates = errors.filter((schema) => Callable.getErrorCode(schema) === code);
+		if (candidates.length === 0 || error.details === void 0) return Effect.fail(fail(new CallableError.ResponseError({
+			code,
+			message: error.message.replace(statusSuffix, ""),
+			details: error.details
+		})));
+		return Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.Union(candidates)))(error.details).pipe(Effect.mapError((cause) => fail(new CallableError.DecodeError({ cause }))), Effect.flatMap(Effect.fail));
+	};
+	return run;
+};
+/**
+* Builds the client of a Callable in no group, or of every Callable member of
+* a Function Group.
+*
+* **When to use**
+*
+* Use to call Callables from the browser or any other client SDK program.
+*
+* **Details**
+*
+* Returns a record keyed by Callable name: `const { greet } = yield*
+* CallableClient.make(Greet)` for a Callable in no group, and
+* `const users = yield* CallableClient.make(Users)` for a group, where
+* `users.create` calls `users-create`. A group's members of other kinds, which
+* no client calls, are left out. The region of the
+* {@link ClientFunctions.ClientFunctions} in context is bound once, here.
+*
+* Build a member's client from its group. A client built from the member on
+* its own calls the name without the group's prefix, which the server doesn't
+* export, and fails with `not-found`. Nothing checks this at runtime.
+*
+* Each call encodes the Payload with `Schema.toCodecJson`, sends it as is
+* through the SDK's `httpsCallable`, and decodes the answer the same way.
+*
+* When the server answers with an error, the client strips the `functions/`
+* prefix from its code and decodes its `details` against the declared errors
+* that carry that code. It fails with the decoded error, so `Effect.catchTag`
+* recovers from it. Every other failure is a
+* {@link CallableError.CallableError}:
+*
+* - `EncodeError` when the Payload doesn't encode. Nothing is sent.
+* - `DecodeError` when the success value doesn't decode, the `details` of
+*   an error don't decode against the declared errors with its code, as after
+*   the server and the client drift apart, or the answer isn't one the SDK
+*   can read: not a JSON object, or one without `data`.
+* - `ResponseError` when the server answers with a code no declared error
+*   carries, or without details, as on a defect. `not-found` usually means a
+*   wrong region, or a name the server doesn't export, such as a group's
+*   member called without its group. A `deadline-exceeded` the server sends
+*   is a `ResponseError` too.
+* - `TransportError` when no answer arrived: a network failure, the SDK's
+*   own timeout (`deadline-exceeded`), a cancelled call, or a deleted
+*   Functions instance. The SDK appends the HTTP status of an answer to its
+*   error's message as ` [<status>]`, and status 0 to a network failure. The
+*   client treats an error without that suffix, or with status 0, as no
+*   answer.
+*
+* Each call runs in a `kind: "client"` span named `CallableClient.<deployed
+* name>`, such as `CallableClient.users-create`, with the attributes
+* `rpc.system: "firebase_callable"`, `rpc.method` (the Callable's name),
+* `rpc.service` (the group, for a member) and `faas.name` (the deployed name).
+* The span isn't linked to the server's span of the same call: the two land in
+* separate traces. It carries no uid; add one with `Effect.annotateCurrentSpan`
+* around the call when you want it.
+*
+* @example Injecting a client as a service
+* ```ts
+* import { Context, Layer, Schema } from "effect";
+* import { Callable } from "@visiolab/effect-firebase/functions";
+* import { CallableClient } from "@visiolab/effect-firebase-client/functions";
+*
+* const Greet = Callable.make("greet", {
+*   payload: { name: Schema.String },
+*   success: Schema.String,
+* });
+*
+* class GreetClient extends Context.Service<GreetClient, CallableClient.Client<typeof Greet>>()(
+*   "app/GreetClient",
+* ) {
+*   static readonly layer = Layer.effect(GreetClient, CallableClient.make(Greet));
+* }
+* ```
+*
+* @example Calling the members of a group
+* ```ts
+* import { Effect, Schema } from "effect";
+* import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+* import { CallableClient } from "@visiolab/effect-firebase-client/functions";
+*
+* const CreateUser = Callable.make("create", {
+*   payload: { name: Schema.String },
+*   success: Schema.String,
+* });
+*
+* class Users extends FunctionGroup.make("users").add(CreateUser) {}
+*
+* const program = Effect.gen(function* () {
+*   const users = yield* CallableClient.make(Users);
+*   // Calls `users-create`.
+*   return yield* users.create({ name: "Ada" });
+* });
+* ```
+*
+* @see {@link ClientFunctions.ClientFunctions} for the region and emulator it calls
+* @see {@link Functions.make} for serving a Callable in no group
+* @see {@link Functions.group} for serving the members of a group
+*
+* @stability unstable
+* @category constructors
+* @since 0.3.0
+*/
+const make = (target) => Effect.map(Effect.service(ClientFunctions), ({ instance }) => {
+	if (!FunctionGroup.isFunctionGroup(target)) {
+		const callable = target;
+		return { [callable.name]: method(instance, callable, Callable.deployment(callable), Callable.errorSchemas(callable)) };
+	}
+	const client = {};
+	for (const [name, member] of Object.entries(target.functions)) {
+		if (member.kind !== "Callable") continue;
+		client[name] = method(instance, member, Callable.deployment(target, name), Callable.errorSchemas(target, name));
+	}
+	return client;
+});
+export { CallableClient_exports, make };
+
+//# sourceMappingURL=CallableClient.mjs.map

package/dist/functions/CallableClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallableClient.mjs","names":["ClientFunctions.ClientFunctions"],"sources":["../../src/functions/CallableClient.ts"],"sourcesContent":["/**\n * Callable Clients: call the Callables a server serves, with the Payload, the\n * success value and the errors typed by their contract.\n *\n * A client calls through the {@link ClientFunctions.ClientFunctions} in\n * context, so the region and the emulator are set once, where that is\n * provided.\n *\n * @example Calling a Callable\n * ```ts\n * import { Effect, Layer, Schema } from \"effect\";\n * import { Callable } from \"@visiolab/effect-firebase/functions\";\n * import { App } from \"@visiolab/effect-firebase-client/app\";\n * import { CallableClient, ClientFunctions } from \"@visiolab/effect-firebase-client/functions\";\n *\n * const Greet = Callable.make(\"greet\", {\n *   payload: { name: Schema.String },\n *   success: Schema.String,\n * });\n *\n * const program = Effect.gen(function* () {\n *   const { greet } = yield* CallableClient.make(Greet);\n *   const message = yield* greet({ name: \"Ada\" });\n *   yield* Effect.log(message);\n * });\n *\n * const FunctionsLive = ClientFunctions.layer().pipe(\n *   Layer.provide(App.layer({ apiKey: \"<api key>\", projectId: \"my-project\", appId: \"<app id>\" })),\n * );\n *\n * program.pipe(Effect.provide(FunctionsLive));\n * ```\n *\n * @stability unstable\n * @since 0.3.0\n */\nimport { Effect, Schema } from \"effect\";\nimport * as Callable from \"@visiolab/effect-firebase/functions/Callable\";\nimport * as CallableError from \"@visiolab/effect-firebase/functions/CallableError\";\nimport * as FunctionGroup from \"@visiolab/effect-firebase/functions/FunctionGroup\";\nimport * as Sdk from \"firebase/functions\";\nimport * as ClientFunctions from \"./ClientFunctions.ts\";\n\n/**\n * A client of one Callable: a function from its Payload to an Effect of its\n * success value, failing with its declared errors or a `CallableError`.\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport type Method<C extends Callable.Any> = (\n  payload: Callable.Payload<C>,\n) => Effect.Effect<Callable.Success<C>, Callable.Error<C> | CallableError.CallableError>;\n\n/**\n * What {@link make} returns: one {@link Method} per Callable, keyed by the\n * Callable's name. For a Function Group, one per Callable member.\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport type Client<T extends Callable.Any | FunctionGroup.Any> = {\n  readonly [C in Members<T> as C[\"name\"]]: Method<C>;\n};\n\n/**\n * The Callables a client of `T` calls: the Callable members of a Function\n * Group, or the Callable itself. Members of other kinds are left out.\n *\n * @stability unstable\n * @category type-level\n * @since 0.3.0\n */\nexport type Members<T extends Callable.Any | FunctionGroup.Any> = T extends FunctionGroup.Any\n  ? FunctionGroup.Members<T, Callable.Any>\n  : T;\n\n/** The ` [<status>]` the SDK appends to the message of an error built from an answer. */\nconst statusSuffix = / \\[(\\d+)\\]$/;\n\n/**\n * The messages of the SDK's errors for an answer it can't read: not a JSON\n * object, or one without `data` or `error`.\n */\nconst malformedAnswer = /Response is (?:not valid JSON object|missing data field)\\.$/;\n\n/**\n * The client function of `callable`, served as `deployment`. `errors` are the\n * schemas of every error it can be answered with, its middleware's included.\n */\nconst method = (\n  functions: Sdk.Functions,\n  callable: Callable.Any,\n  deployment: Callable.Deployment,\n  errors: ReadonlyArray<Schema.Top>,\n) => {\n  const deployedName = deployment.name;\n  const span = { kind: \"client\", attributes: deployment.attributes } as const;\n  const call = Sdk.httpsCallable(functions, deployedName);\n  const encode = Schema.encodeUnknownEffect(\n    Schema.toCodecJson(callable.payload as Schema.Codec<unknown>),\n  );\n  const decode = Schema.decodeUnknownEffect(\n    Schema.toCodecJson(callable.success as Schema.Codec<unknown>),\n  );\n  const fail = (reason: CallableError.Reason) =>\n    new CallableError.CallableError({ callable: deployedName, reason });\n  const run = Effect.fn(\n    `CallableClient.${deployedName}`,\n    span,\n  )(function* (payload: unknown) {\n    const data = yield* encode(payload).pipe(\n      Effect.mapError((cause) => fail(new CallableError.EncodeError({ cause }))),\n    );\n    const result = yield* Effect.tryPromise({\n      try: () => call(data),\n      catch: (error) => error,\n    }).pipe(Effect.catch(decodeFailure));\n    return yield* decode(result.data).pipe(\n      Effect.mapError((cause) => fail(new CallableError.DecodeError({ cause }))),\n    );\n  });\n\n  /**\n   * Turns what the SDK threw into the declared error it carries, or into a\n   * `CallableError`.\n   */\n  const decodeFailure = (error: unknown): Effect.Effect<never, unknown> => {\n    if (!(error instanceof Sdk.FunctionsError)) {\n      return Effect.fail(fail(new CallableError.TransportError({ cause: error })));\n    }\n    // The SDK appends the HTTP status to the message of an error built from\n    // an answer, and status 0 to a network failure. The errors it makes\n    // itself, such as its timeout or a cancellation, carry no status.\n    const status = statusSuffix.exec(error.message)?.[1];\n    if (status === undefined || status === \"0\") {\n      // An answer arrived, but not one the SDK could read.\n      if (malformedAnswer.test(error.message)) {\n        return Effect.fail(fail(new CallableError.DecodeError({ cause: error })));\n      }\n      return Effect.fail(fail(new CallableError.TransportError({ cause: error })));\n    }\n    const code = error.code.replace(/^functions\\//, \"\") as CallableError.ErrorCode;\n    const candidates = errors.filter((schema) => Callable.getErrorCode(schema) === code);\n    if (candidates.length === 0 || error.details === undefined) {\n      return Effect.fail(\n        fail(\n          new CallableError.ResponseError({\n            code,\n            message: error.message.replace(statusSuffix, \"\"),\n            details: error.details,\n          }),\n        ),\n      );\n    }\n    return Schema.decodeUnknownEffect(\n      Schema.toCodecJson(Schema.Union(candidates) as unknown as Schema.Codec<unknown>),\n    )(error.details).pipe(\n      Effect.mapError((cause) => fail(new CallableError.DecodeError({ cause }))),\n      Effect.flatMap(Effect.fail),\n    );\n  };\n  return run;\n};\n\n/**\n * Builds the client of a Callable in no group, or of every Callable member of\n * a Function Group.\n *\n * **When to use**\n *\n * Use to call Callables from the browser or any other client SDK program.\n *\n * **Details**\n *\n * Returns a record keyed by Callable name: `const { greet } = yield*\n * CallableClient.make(Greet)` for a Callable in no group, and\n * `const users = yield* CallableClient.make(Users)` for a group, where\n * `users.create` calls `users-create`. A group's members of other kinds, which\n * no client calls, are left out. The region of the\n * {@link ClientFunctions.ClientFunctions} in context is bound once, here.\n *\n * Build a member's client from its group. A client built from the member on\n * its own calls the name without the group's prefix, which the server doesn't\n * export, and fails with `not-found`. Nothing checks this at runtime.\n *\n * Each call encodes the Payload with `Schema.toCodecJson`, sends it as is\n * through the SDK's `httpsCallable`, and decodes the answer the same way.\n *\n * When the server answers with an error, the client strips the `functions/`\n * prefix from its code and decodes its `details` against the declared errors\n * that carry that code. It fails with the decoded error, so `Effect.catchTag`\n * recovers from it. Every other failure is a\n * {@link CallableError.CallableError}:\n *\n * - `EncodeError` when the Payload doesn't encode. Nothing is sent.\n * - `DecodeError` when the success value doesn't decode, the `details` of\n *   an error don't decode against the declared errors with its code, as after\n *   the server and the client drift apart, or the answer isn't one the SDK\n *   can read: not a JSON object, or one without `data`.\n * - `ResponseError` when the server answers with a code no declared error\n *   carries, or without details, as on a defect. `not-found` usually means a\n *   wrong region, or a name the server doesn't export, such as a group's\n *   member called without its group. A `deadline-exceeded` the server sends\n *   is a `ResponseError` too.\n * - `TransportError` when no answer arrived: a network failure, the SDK's\n *   own timeout (`deadline-exceeded`), a cancelled call, or a deleted\n *   Functions instance. The SDK appends the HTTP status of an answer to its\n *   error's message as ` [<status>]`, and status 0 to a network failure. The\n *   client treats an error without that suffix, or with status 0, as no\n *   answer.\n *\n * Each call runs in a `kind: \"client\"` span named `CallableClient.<deployed\n * name>`, such as `CallableClient.users-create`, with the attributes\n * `rpc.system: \"firebase_callable\"`, `rpc.method` (the Callable's name),\n * `rpc.service` (the group, for a member) and `faas.name` (the deployed name).\n * The span isn't linked to the server's span of the same call: the two land in\n * separate traces. It carries no uid; add one with `Effect.annotateCurrentSpan`\n * around the call when you want it.\n *\n * @example Injecting a client as a service\n * ```ts\n * import { Context, Layer, Schema } from \"effect\";\n * import { Callable } from \"@visiolab/effect-firebase/functions\";\n * import { CallableClient } from \"@visiolab/effect-firebase-client/functions\";\n *\n * const Greet = Callable.make(\"greet\", {\n *   payload: { name: Schema.String },\n *   success: Schema.String,\n * });\n *\n * class GreetClient extends Context.Service<GreetClient, CallableClient.Client<typeof Greet>>()(\n *   \"app/GreetClient\",\n * ) {\n *   static readonly layer = Layer.effect(GreetClient, CallableClient.make(Greet));\n * }\n * ```\n *\n * @example Calling the members of a group\n * ```ts\n * import { Effect, Schema } from \"effect\";\n * import { Callable, FunctionGroup } from \"@visiolab/effect-firebase/functions\";\n * import { CallableClient } from \"@visiolab/effect-firebase-client/functions\";\n *\n * const CreateUser = Callable.make(\"create\", {\n *   payload: { name: Schema.String },\n *   success: Schema.String,\n * });\n *\n * class Users extends FunctionGroup.make(\"users\").add(CreateUser) {}\n *\n * const program = Effect.gen(function* () {\n *   const users = yield* CallableClient.make(Users);\n *   // Calls `users-create`.\n *   return yield* users.create({ name: \"Ada\" });\n * });\n * ```\n *\n * @see {@link ClientFunctions.ClientFunctions} for the region and emulator it calls\n * @see {@link Functions.make} for serving a Callable in no group\n * @see {@link Functions.group} for serving the members of a group\n *\n * @stability unstable\n * @category constructors\n * @since 0.3.0\n */\nexport const make = <T extends Callable.Any | FunctionGroup.Any>(\n  target: T,\n): Effect.Effect<Client<T>, never, ClientFunctions.ClientFunctions> =>\n  Effect.map(Effect.service(ClientFunctions.ClientFunctions), ({ instance }) => {\n    if (!FunctionGroup.isFunctionGroup(target)) {\n      const callable = target as Callable.Any;\n      return {\n        [callable.name]: method(\n          instance,\n          callable,\n          Callable.deployment(callable),\n          Callable.errorSchemas(callable),\n        ),\n      } as Client<T>;\n    }\n    const client: Record<string, ReturnType<typeof method>> = {};\n    for (const [name, member] of Object.entries(target.functions)) {\n      // Only Callables are called by a client.\n      if (member.kind !== \"Callable\") continue;\n      client[name] = method(\n        instance,\n        member as Callable.Any,\n        Callable.deployment(target, name),\n        Callable.errorSchemas(target, name),\n      );\n    }\n    return client as Client<T>;\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAM,eAAe;;;;;AAMrB,MAAM,kBAAkB;;;;;AAMxB,MAAM,UACJ,WACA,UACA,YACA,WACG;CACH,MAAM,eAAe,WAAW;CAChC,MAAM,OAAO;EAAE,MAAM;EAAU,YAAY,WAAW;CAAW;CACjE,MAAM,OAAO,IAAI,cAAc,WAAW,YAAY;CACtD,MAAM,SAAS,OAAO,oBACpB,OAAO,YAAY,SAAS,OAAgC,CAC9D;CACA,MAAM,SAAS,OAAO,oBACpB,OAAO,YAAY,SAAS,OAAgC,CAC9D;CACA,MAAM,QAAQ,WACZ,IAAI,cAAc,cAAc;EAAE,UAAU;EAAc;CAAO,CAAC;CACpE,MAAM,MAAM,OAAO,GACjB,kBAAkB,gBAClB,IACF,CAAC,CAAC,WAAW,SAAkB;EAC7B,MAAM,OAAO,OAAO,OAAO,OAAO,CAAC,CAAC,KAClC,OAAO,UAAU,UAAU,KAAK,IAAI,cAAc,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAC3E;EACA,MAAM,SAAS,OAAO,OAAO,WAAW;GACtC,WAAW,KAAK,IAAI;GACpB,QAAQ,UAAU;EACpB,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,aAAa,CAAC;EACnC,OAAO,OAAO,OAAO,OAAO,IAAI,CAAC,CAAC,KAChC,OAAO,UAAU,UAAU,KAAK,IAAI,cAAc,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAC3E;CACF,CAAC;;;;;CAMD,MAAM,iBAAiB,UAAkD;EACvE,IAAI,EAAE,iBAAiB,IAAI,iBACzB,OAAO,OAAO,KAAK,KAAK,IAAI,cAAc,eAAe,EAAE,OAAO,MAAM,CAAC,CAAC,CAAC;EAK7E,MAAM,SAAS,aAAa,KAAK,MAAM,OAAO,CAAC,GAAG;EAClD,IAAI,WAAW,KAAA,KAAa,WAAW,KAAK;GAE1C,IAAI,gBAAgB,KAAK,MAAM,OAAO,GACpC,OAAO,OAAO,KAAK,KAAK,IAAI,cAAc,YAAY,EAAE,OAAO,MAAM,CAAC,CAAC,CAAC;GAE1E,OAAO,OAAO,KAAK,KAAK,IAAI,cAAc,eAAe,EAAE,OAAO,MAAM,CAAC,CAAC,CAAC;EAC7E;EACA,MAAM,OAAO,MAAM,KAAK,QAAQ,gBAAgB,EAAE;EAClD,MAAM,aAAa,OAAO,QAAQ,WAAW,SAAS,aAAa,MAAM,MAAM,IAAI;EACnF,IAAI,WAAW,WAAW,KAAK,MAAM,YAAY,KAAA,GAC/C,OAAO,OAAO,KACZ,KACE,IAAI,cAAc,cAAc;GAC9B;GACA,SAAS,MAAM,QAAQ,QAAQ,cAAc,EAAE;GAC/C,SAAS,MAAM;EACjB,CAAC,CACH,CACF;EAEF,OAAO,OAAO,oBACZ,OAAO,YAAY,OAAO,MAAM,UAAU,CAAqC,CACjF,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,KACf,OAAO,UAAU,UAAU,KAAK,IAAI,cAAc,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,GACzE,OAAO,QAAQ,OAAO,IAAI,CAC5B;CACF;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuGA,MAAa,QACX,WAEA,OAAO,IAAI,OAAO,QAAQA,eAA+B,IAAI,EAAE,eAAe;CAC5E,IAAI,CAAC,cAAc,gBAAgB,MAAM,GAAG;EAC1C,MAAM,WAAW;EACjB,OAAO,GACJ,SAAS,OAAO,OACf,UACA,UACA,SAAS,WAAW,QAAQ,GAC5B,SAAS,aAAa,QAAQ,CAChC,EACF;CACF;CACA,MAAM,SAAoD,CAAC;CAC3D,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,OAAO,SAAS,GAAG;EAE7D,IAAI,OAAO,SAAS,YAAY;EAChC,OAAO,QAAQ,OACb,UACA,QACA,SAAS,WAAW,QAAQ,IAAI,GAChC,SAAS,aAAa,QAAQ,IAAI,CACpC;CACF;CACA,OAAO;AACT,CAAC"}

package/dist/functions/ClientFunctions.d.mts

@@ -0,0 +1,112 @@
+import { App } from "../app/App.mjs";
+import { Context, Effect, Layer } from "effect";
+import * as Client from "firebase/functions";
+declare namespace ClientFunctions_d_exports {
+  export { ClientFunctions, Emulator, Options, layer, make };
+}
+/**
+ * The client SDK's `Functions` instance for one region.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface ClientFunctions {
+  /** The SDK's own `Functions` instance, for what this package doesn't wrap. */
+  readonly instance: Client.Functions;
+}
+/**
+ * Service key for {@link ClientFunctions}.
+ *
+ * **When to use**
+ *
+ * Use to give every Callable Client one region and emulator setting. Provide
+ * it with {@link layer}. A {@link CallableClient.make} client reads it once,
+ * when it is built.
+ *
+ * @see {@link layer} for providing it
+ * @see {@link CallableClient.make} for the clients that call through it
+ *
+ * @stability unstable
+ * @category services
+ * @since 0.3.0
+ */
+export declare const ClientFunctions: Context.Service<ClientFunctions, ClientFunctions>;
+/**
+ * Where the Functions emulator runs.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Emulator {
+  readonly host: string;
+  readonly port: number;
+}
+/**
+ * Options for {@link make} and {@link layer}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Options {
+  /**
+   * The region the functions are deployed to, such as `europe-west1`, or a
+   * custom domain that serves them. Defaults to the SDK's, `us-central1`. A
+   * function called in a region it isn't deployed to fails with `not-found`.
+   */
+  readonly regionOrCustomDomain?: string | undefined;
+  /** Calls the Functions emulator at this address instead of the deployed functions. */
+  readonly emulator?: Emulator | undefined;
+}
+/**
+ * Gets the client SDK's `Functions` instance of the {@link App.App} in
+ * context, for one region.
+ *
+ * **When to use**
+ *
+ * Use to build the service inside an effect of your own. Most programs provide
+ * it with {@link layer} instead.
+ *
+ * **Details**
+ *
+ * Wraps `getFunctions(app, regionOrCustomDomain)`, and connects the emulator
+ * when `emulator` is given. For a second region, build a second service.
+ *
+ * @see {@link layer} for the same as a layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const make: (options?: Options) => Effect.Effect<ClientFunctions, never, App>;
+/**
+ * A layer that provides {@link ClientFunctions} for the {@link App.App} in
+ * context.
+ *
+ * **When to use**
+ *
+ * Use to set the region and the emulator once, for every Callable Client built
+ * on it.
+ *
+ * @example Calling the Functions emulator
+ * ```ts
+ * import { Layer } from "effect";
+ * import { App } from "@visiolab/effect-firebase-client/app";
+ * import { ClientFunctions } from "@visiolab/effect-firebase-client/functions";
+ *
+ * const FunctionsLive = ClientFunctions.layer({
+ *   emulator: { host: "127.0.0.1", port: 5001 },
+ * }).pipe(Layer.provide(App.layer({ projectId: "demo-project" })));
+ * ```
+ *
+ * @see {@link make} for what it wraps
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.3.0
+ */
+export declare const layer: (options?: Options) => Layer.Layer<ClientFunctions, never, App>;
+export { ClientFunctions_d_exports };
+//# sourceMappingURL=ClientFunctions.d.mts.map

package/dist/functions/ClientFunctions.mjs

@@ -0,0 +1,105 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { App } from "../app/App.mjs";
+import { Context, Effect, Layer } from "effect";
+import * as Client from "firebase/functions";
+// src/functions/ClientFunctions.ts
+/**
+* Cloud Functions for Firebase on the client SDK: the `Functions` instance
+* that a Callable Client calls through, for one region.
+*
+* A call that fails with `not-found` usually went to the wrong region, or to a
+* name the server doesn't export: build the client of a Function Group's
+* member from its group, so it calls `<group>-<name>`.
+*
+* @example Pointing the client at a region
+* ```ts
+* import { Layer } from "effect";
+* import { App } from "@visiolab/effect-firebase-client/app";
+* import { ClientFunctions } from "@visiolab/effect-firebase-client/functions";
+*
+* const FunctionsLive = ClientFunctions.layer({ regionOrCustomDomain: "europe-west1" }).pipe(
+*   Layer.provide(App.layer({ apiKey: "<api key>", projectId: "my-project", appId: "<app id>" })),
+* );
+* ```
+*
+* @stability unstable
+* @since 0.3.0
+*/
+var ClientFunctions_exports = /* @__PURE__ */ __exportAll({
+	ClientFunctions: () => ClientFunctions,
+	layer: () => layer,
+	make: () => make
+});
+/**
+* Service key for {@link ClientFunctions}.
+*
+* **When to use**
+*
+* Use to give every Callable Client one region and emulator setting. Provide
+* it with {@link layer}. A {@link CallableClient.make} client reads it once,
+* when it is built.
+*
+* @see {@link layer} for providing it
+* @see {@link CallableClient.make} for the clients that call through it
+*
+* @stability unstable
+* @category services
+* @since 0.3.0
+*/
+const ClientFunctions = Context.Service("@visiolab/effect-firebase-client/functions/ClientFunctions");
+/**
+* Gets the client SDK's `Functions` instance of the {@link App.App} in
+* context, for one region.
+*
+* **When to use**
+*
+* Use to build the service inside an effect of your own. Most programs provide
+* it with {@link layer} instead.
+*
+* **Details**
+*
+* Wraps `getFunctions(app, regionOrCustomDomain)`, and connects the emulator
+* when `emulator` is given. For a second region, build a second service.
+*
+* @see {@link layer} for the same as a layer
+*
+* @stability unstable
+* @category constructors
+* @since 0.3.0
+*/
+const make = Effect.fn("ClientFunctions.make")(function* (options) {
+	const app = yield* App;
+	const instance = Client.getFunctions(app, options?.regionOrCustomDomain);
+	if (options?.emulator !== void 0) Client.connectFunctionsEmulator(instance, options.emulator.host, options.emulator.port);
+	return { instance };
+});
+/**
+* A layer that provides {@link ClientFunctions} for the {@link App.App} in
+* context.
+*
+* **When to use**
+*
+* Use to set the region and the emulator once, for every Callable Client built
+* on it.
+*
+* @example Calling the Functions emulator
+* ```ts
+* import { Layer } from "effect";
+* import { App } from "@visiolab/effect-firebase-client/app";
+* import { ClientFunctions } from "@visiolab/effect-firebase-client/functions";
+*
+* const FunctionsLive = ClientFunctions.layer({
+*   emulator: { host: "127.0.0.1", port: 5001 },
+* }).pipe(Layer.provide(App.layer({ projectId: "demo-project" })));
+* ```
+*
+* @see {@link make} for what it wraps
+*
+* @stability unstable
+* @category layers
+* @since 0.3.0
+*/
+const layer = (options) => Layer.effect(ClientFunctions, make(options));
+export { ClientFunctions, ClientFunctions_exports, layer, make };
+
+//# sourceMappingURL=ClientFunctions.mjs.map

package/dist/functions/ClientFunctions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientFunctions.mjs","names":["App.App"],"sources":["../../src/functions/ClientFunctions.ts"],"sourcesContent":["/**\n * Cloud Functions for Firebase on the client SDK: the `Functions` instance\n * that a Callable Client calls through, for one region.\n *\n * A call that fails with `not-found` usually went to the wrong region, or to a\n * name the server doesn't export: build the client of a Function Group's\n * member from its group, so it calls `<group>-<name>`.\n *\n * @example Pointing the client at a region\n * ```ts\n * import { Layer } from \"effect\";\n * import { App } from \"@visiolab/effect-firebase-client/app\";\n * import { ClientFunctions } from \"@visiolab/effect-firebase-client/functions\";\n *\n * const FunctionsLive = ClientFunctions.layer({ regionOrCustomDomain: \"europe-west1\" }).pipe(\n *   Layer.provide(App.layer({ apiKey: \"<api key>\", projectId: \"my-project\", appId: \"<app id>\" })),\n * );\n * ```\n *\n * @stability unstable\n * @since 0.3.0\n */\nimport { Context, Effect, Layer } from \"effect\";\nimport * as Client from \"firebase/functions\";\nimport * as App from \"../app/App.ts\";\n// Only the documentation links to it.\n// oxlint-disable-next-line no-unused-vars\nimport type * as CallableClient from \"./CallableClient.ts\";\n\n/**\n * The client SDK's `Functions` instance for one region.\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport interface ClientFunctions {\n  /** The SDK's own `Functions` instance, for what this package doesn't wrap. */\n  readonly instance: Client.Functions;\n}\n\n/**\n * Service key for {@link ClientFunctions}.\n *\n * **When to use**\n *\n * Use to give every Callable Client one region and emulator setting. Provide\n * it with {@link layer}. A {@link CallableClient.make} client reads it once,\n * when it is built.\n *\n * @see {@link layer} for providing it\n * @see {@link CallableClient.make} for the clients that call through it\n *\n * @stability unstable\n * @category services\n * @since 0.3.0\n */\nexport const ClientFunctions = Context.Service<ClientFunctions>(\n  \"@visiolab/effect-firebase-client/functions/ClientFunctions\",\n);\n\n/**\n * Where the Functions emulator runs.\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport interface Emulator {\n  readonly host: string;\n  readonly port: number;\n}\n\n/**\n * Options for {@link make} and {@link layer}.\n *\n * @stability unstable\n * @category models\n * @since 0.3.0\n */\nexport interface Options {\n  /**\n   * The region the functions are deployed to, such as `europe-west1`, or a\n   * custom domain that serves them. Defaults to the SDK's, `us-central1`. A\n   * function called in a region it isn't deployed to fails with `not-found`.\n   */\n  readonly regionOrCustomDomain?: string | undefined;\n  /** Calls the Functions emulator at this address instead of the deployed functions. */\n  readonly emulator?: Emulator | undefined;\n}\n\n/**\n * Gets the client SDK's `Functions` instance of the {@link App.App} in\n * context, for one region.\n *\n * **When to use**\n *\n * Use to build the service inside an effect of your own. Most programs provide\n * it with {@link layer} instead.\n *\n * **Details**\n *\n * Wraps `getFunctions(app, regionOrCustomDomain)`, and connects the emulator\n * when `emulator` is given. For a second region, build a second service.\n *\n * @see {@link layer} for the same as a layer\n *\n * @stability unstable\n * @category constructors\n * @since 0.3.0\n */\nexport const make: (options?: Options) => Effect.Effect<ClientFunctions, never, App.App> =\n  Effect.fn(\"ClientFunctions.make\")(function* (options?: Options) {\n    const app = yield* App.App;\n    const instance = Client.getFunctions(app, options?.regionOrCustomDomain);\n    if (options?.emulator !== undefined) {\n      Client.connectFunctionsEmulator(instance, options.emulator.host, options.emulator.port);\n    }\n    return { instance };\n  });\n\n/**\n * A layer that provides {@link ClientFunctions} for the {@link App.App} in\n * context.\n *\n * **When to use**\n *\n * Use to set the region and the emulator once, for every Callable Client built\n * on it.\n *\n * @example Calling the Functions emulator\n * ```ts\n * import { Layer } from \"effect\";\n * import { App } from \"@visiolab/effect-firebase-client/app\";\n * import { ClientFunctions } from \"@visiolab/effect-firebase-client/functions\";\n *\n * const FunctionsLive = ClientFunctions.layer({\n *   emulator: { host: \"127.0.0.1\", port: 5001 },\n * }).pipe(Layer.provide(App.layer({ projectId: \"demo-project\" })));\n * ```\n *\n * @see {@link make} for what it wraps\n *\n * @stability unstable\n * @category layers\n * @since 0.3.0\n */\nexport const layer = (options?: Options): Layer.Layer<ClientFunctions, never, App.App> =>\n  Layer.effect(ClientFunctions, make(options));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAa,kBAAkB,QAAQ,QACrC,4DACF;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,OACX,OAAO,GAAG,sBAAsB,CAAC,CAAC,WAAW,SAAmB;CAC9D,MAAM,MAAM,OAAOA;CACnB,MAAM,WAAW,OAAO,aAAa,KAAK,SAAS,oBAAoB;CACvE,IAAI,SAAS,aAAa,KAAA,GACxB,OAAO,yBAAyB,UAAU,QAAQ,SAAS,MAAM,QAAQ,SAAS,IAAI;CAExF,OAAO,EAAE,SAAS;AACpB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BH,MAAa,SAAS,YACpB,MAAM,OAAO,iBAAiB,KAAK,OAAO,CAAC"}

package/dist/functions/index.d.mts

@@ -0,0 +1,3 @@
+import { ClientFunctions_d_exports } from "./ClientFunctions.mjs";
+import { CallableClient_d_exports } from "./CallableClient.mjs";
+export { CallableClient_d_exports as CallableClient, ClientFunctions_d_exports as ClientFunctions };

package/dist/functions/index.mjs

@@ -0,0 +1,3 @@
+import { ClientFunctions_exports } from "./ClientFunctions.mjs";
+import { CallableClient_exports } from "./CallableClient.mjs";
+export { CallableClient_exports as CallableClient, ClientFunctions_exports as ClientFunctions };

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@visiolab/effect-firebase-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.0",
+  "description": "Firebase client SDK implementation of the @visiolab/effect-firebase services.",
+  "keywords": [
+    "effect",
+    "firebase",
+    "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/client"
+  },
+  "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",
+    "./firestore": "./dist/firestore/index.mjs",
+    "./firestore/ClientDocumentSnapshot": "./dist/firestore/ClientDocumentSnapshot.mjs",
+    "./firestore/ClientFirestore": "./dist/firestore/ClientFirestore.mjs",
+    "./firestore/ClientFirestoreValue": "./dist/firestore/ClientFirestoreValue.mjs",
+    "./firestore/ClientQuerySnapshot": "./dist/firestore/ClientQuerySnapshot.mjs",
+    "./functions": "./dist/functions/index.mjs",
+    "./functions/CallableClient": "./dist/functions/CallableClient.mjs",
+    "./functions/ClientFunctions": "./dist/functions/ClientFunctions.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^4.1.0",
+    "effect": "4.1.0",
+    "firebase": "^13.0.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": "^13.0.0",
+    "@visiolab/effect-firebase": "^0.3.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
 }