@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/src/functions/internal/callableMiddleware.ts

@@ -0,0 +1,54 @@
+/** @internal */
+import { Context, type Effect, type Schema } from "effect";
+
+/** @internal */
+export const TypeId = "~@visiolab/effect-firebase/functions/CallableMiddleware";
+
+/**
+ * A middleware's key as the chain reads it, with its types erased.
+ *
+ * @internal
+ */
+export interface Key extends Context.Key<never, Implementation> {
+  readonly [TypeId]: typeof TypeId;
+  readonly error: ReadonlySet<Schema.Top>;
+}
+
+/**
+ * A middleware's implementation as the chain runs it.
+ *
+ * @internal
+ */
+export type Implementation = (
+  effect: Effect.Effect<unknown, unknown>,
+  options: { readonly callable: unknown },
+) => Effect.Effect<unknown, unknown>;
+
+/**
+ * The middleware attached to a Callable, as a union, from its phantom
+ * `~Middleware` field.
+ *
+ * @internal
+ */
+export type Attached<X> = X extends { readonly "~Middleware": infer M } ? M : never;
+
+/**
+ * What the middleware attached to a Callable still requires, from its phantom
+ * `~MiddlewareServices` field.
+ *
+ * @internal
+ */
+export type AttachedServices<X> = X extends { readonly "~MiddlewareServices": infer R } ? R : never;
+
+/** @internal */
+export const Service = (
+  id: string,
+  options?: { readonly error?: Schema.Top | ReadonlyArray<Schema.Top> | undefined },
+) => {
+  class Service extends Context.Service<Service, any>()(id) {}
+  const self = Service as any;
+  self[TypeId] = TypeId;
+  const error = options?.error;
+  self.error = new Set(error === undefined ? [] : Array.isArray(error) ? error : [error]);
+  return self;
+};

package/src/functions/internal/callableRequest.ts

@@ -0,0 +1,8 @@
+/** @internal */
+import { Context } from "effect";
+import type * as Public from "../CallableRequest.ts";
+
+/** @internal */
+export const CallableRequest = Context.Service<Public.CallableRequest>(
+  "@visiolab/effect-firebase/functions/CallableRequest",
+);

package/src/functions/internal/documentTrigger.ts

@@ -0,0 +1,143 @@
+/** @internal */
+import { Context, Effect, Layer, Pipeable } from "effect";
+import type * as Collection from "../../firestore/Collection.ts";
+import type * as DocumentSnapshot from "../../firestore/DocumentSnapshot.ts";
+import * as FirebaseFunction from "./firebaseFunction.ts";
+
+/** @internal */
+export const TypeId = "~@visiolab/effect-firebase/functions/DocumentTrigger";
+
+/** @internal */
+export const kind = "DocumentTrigger";
+
+/**
+ * The changes to a document a trigger can listen to.
+ *
+ * @internal
+ */
+export type EventKind = "created" | "deleted" | "updated" | "written";
+
+/** @internal */
+export interface Fields extends FirebaseFunction.Fields {
+  readonly kind: typeof kind;
+  readonly name: string;
+  readonly event: EventKind;
+  readonly collection: Collection.Any;
+}
+
+const Proto = {
+  [TypeId]: TypeId,
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  },
+};
+
+/** @internal */
+export const make = (fields: Fields): Fields => Object.assign(Object.create(Proto), fields);
+
+/** @internal */
+export const isDocumentTrigger = (u: unknown): u is Fields =>
+  typeof u === "object" && u !== null && TypeId in u;
+
+/**
+ * A handler as it sits in the context: the services it was built with are
+ * already provided, so it needs only those of the event.
+ *
+ * @internal
+ */
+export type HandlerService = (event: unknown) => Effect.Effect<void, unknown>;
+
+/**
+ * What `toLayer` takes, with the types its signature has already checked
+ * erased.
+ *
+ * @internal
+ */
+export type HandlerInput = HandlerService | Effect.Effect<HandlerService>;
+
+/**
+ * The key of the handler of the Document Trigger `name` in `group`, or in no
+ * group.
+ *
+ * @internal
+ */
+export const handlerKey = (group: string | undefined, name: string) =>
+  FirebaseFunction.handlerKey<HandlerService>(group, name);
+
+/** @internal */
+export const toLayer = (group: string | undefined, name: string, handler: HandlerInput) =>
+  Layer.effect(
+    handlerKey(group, name),
+    Effect.gen(function* () {
+      const run = Effect.isEffect(handler) ? yield* handler : handler;
+      // The services the Layer was built with, under those of the event.
+      const built = yield* Effect.context<never>();
+      return (event: unknown) =>
+        Effect.updateContext(run(event), (call: Context.Context<never>) =>
+          Context.merge(built, call),
+        );
+    }),
+  );
+
+/** @internal */
+export const serve = (group: FirebaseFunction.Group | undefined, trigger: Fields) =>
+  Effect.service(handlerKey(group?.identifier, trigger.name));
+
+/**
+ * The path pattern of the documents of `collection`, with a wildcard of its
+ * own for each ancestor id and for the document id:
+ * `users/{id0}/posts/{id1}`. The wildcards are only ever read back through
+ * the event's document path, so their names are free.
+ *
+ * @internal
+ */
+export const documentPattern = (collection: Collection.Any): string =>
+  collection.path.map((segment, i) => `${segment}/{id${i}}`).join("/");
+
+/** @internal */
+export const deployment = (group: FirebaseFunction.Group | undefined, trigger: Fields) => ({
+  name: FirebaseFunction.deployedName(group, trigger),
+  document: documentPattern(trigger.collection),
+});
+
+/** @internal */
+export const createdEvent = <C extends Collection.Any>(input: {
+  readonly id: string;
+  readonly time: string;
+  readonly snapshot: DocumentSnapshot.Existing<C>;
+}) => ({
+  id: input.id,
+  time: input.time,
+  ref: input.snapshot.ref,
+  snapshot: input.snapshot,
+});
+
+/**
+ * A `deleted` event has the shape of a `created` one, with the document as it
+ * was just before it was deleted.
+ *
+ * @internal
+ */
+export const deletedEvent = createdEvent;
+
+/**
+ * The event of a change with a document on each side. Both sides are at the
+ * same reference; `ref` is taken from `after`.
+ *
+ * @internal
+ */
+export const changeEvent = <
+  C extends Collection.Any,
+  S extends DocumentSnapshot.DocumentSnapshot<C>,
+>(input: {
+  readonly id: string;
+  readonly time: string;
+  readonly before: S;
+  readonly after: S;
+}) => ({
+  id: input.id,
+  time: input.time,
+  ref: input.after.ref,
+  before: input.before,
+  after: input.after,
+});

package/src/functions/internal/firebaseFunction.ts

@@ -0,0 +1,58 @@
+/** @internal */
+import { Context } from "effect";
+
+/** @internal */
+export const TypeId = "~@visiolab/effect-firebase/functions/FirebaseFunction";
+
+/** @internal */
+export const NoGroupTypeId = "~@visiolab/effect-firebase/functions/FirebaseFunction/NoGroup";
+
+/** @internal */
+export const HandlerTypeId = "~@visiolab/effect-firebase/functions/FirebaseFunction/Handler";
+
+/**
+ * What every kind of Function holds: its kind and its name.
+ *
+ * @internal
+ */
+export interface Fields {
+  readonly kind: string;
+  readonly name: string;
+}
+
+/**
+ * The fields of a Function Group that a Function in it is served by.
+ *
+ * @internal
+ */
+export interface Group {
+  readonly identifier: string;
+}
+
+/**
+ * The key of the handler of the Function `name` in `group`, or in no group,
+ * whatever its kind. A kind decides what it holds.
+ *
+ * Context keys are compared by their string, so every call with the same group
+ * and name reaches the same service. Deployed names can't contain `/`, so the
+ * two forms can't collide. Names are unique within a group, and a Function in
+ * no group is deployed under its name, so two kinds never share a key they
+ * could both be served under.
+ *
+ * @internal
+ */
+export const handlerKey = <S>(group: string | undefined, name: string) =>
+  Context.Service<never, S>(
+    group === undefined
+      ? `@visiolab/effect-firebase/functions/Handler/${name}`
+      : `@visiolab/effect-firebase/functions/Handler/${group}/${name}`,
+  );
+
+/**
+ * The name `fn` is deployed under: its own in no group, or `<group>-<name>`
+ * in `group`.
+ *
+ * @internal
+ */
+export const deployedName = (group: Group | undefined, fn: Fields): string =>
+  group === undefined ? fn.name : `${group.identifier}-${fn.name}`;

package/src/functions/internal/functionGroup.ts

@@ -0,0 +1,47 @@
+/** @internal */
+import { Pipeable } from "effect";
+import type * as FirebaseFunction from "./firebaseFunction.ts";
+
+/** @internal */
+export const TypeId = "~@visiolab/effect-firebase/functions/FunctionGroup";
+
+/** @internal */
+export interface Fields {
+  readonly identifier: string;
+  readonly functions: Readonly<Record<string, FirebaseFunction.Fields>>;
+}
+
+/** @internal */
+export const isFunctionGroup = (u: unknown): u is Fields =>
+  (typeof u === "function" || (typeof u === "object" && u !== null)) && TypeId in u;
+
+const Proto = {
+  [TypeId]: TypeId,
+  add(this: Fields, ...toAdd: ReadonlyArray<FirebaseFunction.Fields>) {
+    const functions = { ...this.functions };
+    for (const fn of toAdd) {
+      if (Object.hasOwn(functions, fn.name)) {
+        throw new Error(
+          `The Function Group "${this.identifier}" already has a Function named "${fn.name}"`,
+        );
+      }
+      functions[fn.name] = fn;
+    }
+    return make({ identifier: this.identifier, functions });
+  },
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  },
+};
+
+/**
+ * A function, so that a group can be the base of a class. Its `name` is the
+ * function's own, so the group's name is its `identifier`.
+ *
+ * @internal
+ */
+export const make = (fields: Fields) => {
+  function FunctionGroup() {}
+  Object.setPrototypeOf(FunctionGroup, Proto);
+  return Object.assign(FunctionGroup, fields);
+};