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

package/dist/internal/runtime.mjs

@@ -0,0 +1,79 @@
+import { layer } from "../logger/CloudLogging.mjs";
+import { DeferredTracer, externalParent } from "./serverSpan.mjs";
+import { Context, Effect, Exit, Layer, Logger, Scope } from "effect";
+// src/internal/runtime.ts
+/**
+* What every kind of Function runs an event or a call under: the lazy,
+* memoized build of its Layer, its server span, its Tracer and its logs.
+*
+* A kind's runtime turns what `firebase-functions` hands over into the input
+* of its core `serve`, and passes that to {@link make}'s run function, which
+* does the rest.
+*
+* @internal
+*/
+/**
+* The memo map and scope every Layer of this process is built in, so a Layer
+* that several exports share is built once. The scope is never closed:
+* functions-framework exits the process without waiting for finalizers.
+*/
+const memoMap = Layer.makeMemoMapUnsafe();
+const scope = Scope.makeUnsafe();
+/**
+* Builds `live` on the first event, and hands every later event the same
+* services. Concurrent first events share one build. The build runs under the
+* span and Tracer of the event that starts it, so it nests under that event.
+*
+* A failed build fails the event and is tried again on the next one. A Layer
+* that fails closes the scope it was built in, which drops its failed entries
+* from the memo map, so the retry builds anew.
+*/
+const lazyContext = (live) => {
+	let pending;
+	return Effect.flatMap(Effect.context(), (caller) => {
+		pending ??= Effect.runPromiseExit(Layer.buildWithMemoMap(live, memoMap, scope).pipe(Effect.provideContext(caller))).then((exit) => {
+			if (Exit.isFailure(exit)) pending = void 0;
+			return exit;
+		});
+		const attempt = pending;
+		return Effect.flatten(Effect.promise(() => attempt));
+	});
+};
+/**
+* The run function of one export: it builds `live` on the export's first
+* event or call, so a worker that serves one export builds nothing for the
+* others, and runs each `body` with the services of `live` provided.
+*
+* The run happens in a `kind: "server"` span, parented on the trace context
+* Firebase read from the event or request. Its spans go to the Tracer of
+* `live`, its logs go through `CloudLogging.layer` unless `live` provides a
+* logger, and logs from before `live` is built wait until the spans have
+* their final ids.
+*
+* Read the trace context synchronously, at the start of the SDK's handler:
+* call the run function there.
+*
+* @internal
+*/
+const make = (live, options) => {
+	const context = lazyContext(live);
+	const spanOptions = {
+		kind: "server",
+		attributes: options.attributes
+	};
+	return (body, signal) => {
+		const parent = externalParent();
+		const deferred = new DeferredTracer();
+		return Effect.runPromiseExit(Effect.gen(function* () {
+			const services = yield* context.pipe(Effect.onError(() => Effect.sync(() => deferred.attach(Context.empty()))), Effect.onError(options.onBuildFailure));
+			deferred.attach(services);
+			return yield* Effect.provideContext(body, services);
+		}).pipe(Effect.withSpan(options.span, {
+			...spanOptions,
+			parent
+		}), Effect.updateService(Logger.CurrentLoggers, (loggers) => deferred.holdLogs(loggers)), Effect.provide(layer), Effect.withTracer(deferred.tracer)), signal === void 0 ? void 0 : { signal });
+	};
+};
+export { make };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/internal/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":["CloudLogging.layer"],"sources":["../../src/internal/runtime.ts"],"sourcesContent":["/**\n * What every kind of Function runs an event or a call under: the lazy,\n * memoized build of its Layer, its server span, its Tracer and its logs.\n *\n * A kind's runtime turns what `firebase-functions` hands over into the input\n * of its core `serve`, and passes that to {@link make}'s run function, which\n * does the rest.\n *\n * @internal\n */\nimport { type Cause, Context, Effect, Exit, Layer, Logger, Scope } from \"effect\";\nimport * as CloudLogging from \"../logger/CloudLogging.ts\";\nimport { DeferredTracer, externalParent } from \"./serverSpan.ts\";\n\n/**\n * The memo map and scope every Layer of this process is built in, so a Layer\n * that several exports share is built once. The scope is never closed:\n * functions-framework exits the process without waiting for finalizers.\n */\nconst memoMap = Layer.makeMemoMapUnsafe();\nconst scope = Scope.makeUnsafe();\n\n/**\n * Builds `live` on the first event, and hands every later event the same\n * services. Concurrent first events share one build. The build runs under the\n * span and Tracer of the event that starts it, so it nests under that event.\n *\n * A failed build fails the event and is tried again on the next one. A Layer\n * that fails closes the scope it was built in, which drops its failed entries\n * from the memo map, so the retry builds anew.\n */\nconst lazyContext = <R, E>(live: Layer.Layer<R, E>) => {\n  let pending: Promise<Exit.Exit<Context.Context<R>, E>> | undefined;\n  return Effect.flatMap(Effect.context<never>(), (caller) => {\n    pending ??= Effect.runPromiseExit(\n      Layer.buildWithMemoMap(live, memoMap, scope).pipe(Effect.provideContext(caller)),\n    ).then((exit) => {\n      if (Exit.isFailure(exit)) pending = undefined;\n      return exit;\n    });\n    const attempt = pending;\n    return Effect.flatten(Effect.promise(() => attempt));\n  });\n};\n\n/**\n * How one export runs each event or call.\n *\n * @internal\n */\nexport interface Options {\n  /** The name of the `kind: \"server\"` span each event or call runs in. */\n  readonly span: string;\n  /** The attributes of that span. */\n  readonly attributes: Readonly<Record<string, unknown>>;\n  /**\n   * Logs the Cause of a Layer that failed to build, in the span of the event\n   * or call that built it.\n   */\n  readonly onBuildFailure: (cause: Cause.Cause<unknown>) => Effect.Effect<void>;\n}\n\n/**\n * The run function of one export: it builds `live` on the export's first\n * event or call, so a worker that serves one export builds nothing for the\n * others, and runs each `body` with the services of `live` provided.\n *\n * The run happens in a `kind: \"server\"` span, parented on the trace context\n * Firebase read from the event or request. Its spans go to the Tracer of\n * `live`, its logs go through `CloudLogging.layer` unless `live` provides a\n * logger, and logs from before `live` is built wait until the spans have\n * their final ids.\n *\n * Read the trace context synchronously, at the start of the SDK's handler:\n * call the run function there.\n *\n * @internal\n */\nexport const make = <R, E>(live: Layer.Layer<R, E>, options: Options) => {\n  const context = lazyContext(live);\n  const spanOptions = { kind: \"server\", attributes: options.attributes } as const;\n  return <A>(\n    body: Effect.Effect<A, unknown, unknown>,\n    signal?: AbortSignal,\n  ): Promise<Exit.Exit<A, unknown>> => {\n    const parent = externalParent();\n    const deferred = new DeferredTracer();\n    return Effect.runPromiseExit(\n      Effect.gen(function* () {\n        const services = yield* context.pipe(\n          // With no services to take a Tracer from, the run's spans and held\n          // logs go to the native Tracer, so the failure is logged in one trace.\n          Effect.onError(() => Effect.sync(() => deferred.attach(Context.empty()))),\n          Effect.onError(options.onBuildFailure),\n        );\n        deferred.attach(services as Context.Context<never>);\n        // The public signatures check that `live` provides what `body` needs.\n        return yield* Effect.provideContext(body, services as Context.Context<any>);\n      }).pipe(\n        Effect.withSpan(options.span, { ...spanOptions, parent }),\n        // Logs from before `live` is built wait for the spans' real ids.\n        Effect.updateService(Logger.CurrentLoggers, (loggers) => deferred.holdLogs(loggers)),\n        // Beneath `live`: a logger that `live` provides replaces this one.\n        Effect.provide(CloudLogging.layer),\n        Effect.withTracer(deferred.tracer),\n      ),\n      signal === undefined ? undefined : { signal },\n    );\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAM,UAAU,MAAM,kBAAkB;AACxC,MAAM,QAAQ,MAAM,WAAW;;;;;;;;;;AAW/B,MAAM,eAAqB,SAA4B;CACrD,IAAI;CACJ,OAAO,OAAO,QAAQ,OAAO,QAAe,IAAI,WAAW;EACzD,YAAY,OAAO,eACjB,MAAM,iBAAiB,MAAM,SAAS,KAAK,CAAC,CAAC,KAAK,OAAO,eAAe,MAAM,CAAC,CACjF,CAAC,CAAC,MAAM,SAAS;GACf,IAAI,KAAK,UAAU,IAAI,GAAG,UAAU,KAAA;GACpC,OAAO;EACT,CAAC;EACD,MAAM,UAAU;EAChB,OAAO,OAAO,QAAQ,OAAO,cAAc,OAAO,CAAC;CACrD,CAAC;AACH;;;;;;;;;;;;;;;;;AAmCA,MAAa,QAAc,MAAyB,YAAqB;CACvE,MAAM,UAAU,YAAY,IAAI;CAChC,MAAM,cAAc;EAAE,MAAM;EAAU,YAAY,QAAQ;CAAW;CACrE,QACE,MACA,WACmC;EACnC,MAAM,SAAS,eAAe;EAC9B,MAAM,WAAW,IAAI,eAAe;EACpC,OAAO,OAAO,eACZ,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,QAAQ,KAG9B,OAAO,cAAc,OAAO,WAAW,SAAS,OAAO,QAAQ,MAAM,CAAC,CAAC,CAAC,GACxE,OAAO,QAAQ,QAAQ,cAAc,CACvC;GACA,SAAS,OAAO,QAAkC;GAElD,OAAO,OAAO,OAAO,eAAe,MAAM,QAAgC;EAC5E,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,QAAQ,MAAM;GAAE,GAAG;GAAa;EAAO,CAAC,GAExD,OAAO,cAAc,OAAO,iBAAiB,YAAY,SAAS,SAAS,OAAO,CAAC,GAEnF,OAAO,QAAQA,KAAkB,GACjC,OAAO,WAAW,SAAS,MAAM,CACnC,GACA,WAAW,KAAA,IAAY,KAAA,IAAY,EAAE,OAAO,CAC9C;CACF;AACF"}

package/dist/internal/serverSpan.mjs

@@ -0,0 +1,187 @@
+import { Context, Logger, Option, Tracer } from "effect";
+import { traceContext } from "firebase-functions/v2";
+// src/internal/serverSpan.ts
+/** @internal */
+/**
+* The parent of a call's server span: the trace context `firebase-functions`
+* read from the request's headers, the `X-Cloud-Trace-Context` header winning
+* over `traceparent`. Read it synchronously at the start of the call, before
+* any fiber runs: Effect's scheduler may later run under another request's
+* async store. `undefined` when the request carried none, as in the emulator.
+*
+* @internal
+*/
+const externalParent = () => {
+	const store = traceContext.getStore();
+	if (store === void 0) return void 0;
+	return Tracer.externalSpan({
+		traceId: store.traceId,
+		spanId: store.parentId.padStart(16, "0"),
+		sampled: store.sample
+	});
+};
+/**
+* A span opened before the Tracer of `Live` is known. It records what happens
+* to it, and replays that onto the real span once {@link DeferredTracer.attach}
+* creates it. From then on it forwards everything.
+*/
+var DeferredSpan = class DeferredSpan {
+	_tag = "Span";
+	name;
+	parent;
+	annotations;
+	kind;
+	sampled;
+	options;
+	real;
+	calls = [];
+	pendingAttributes = /* @__PURE__ */ new Map();
+	pendingLinks;
+	pendingStatus;
+	provisional;
+	constructor(options) {
+		this.options = options;
+		this.name = options.name;
+		this.parent = options.parent;
+		this.annotations = options.annotations;
+		this.kind = options.kind;
+		this.sampled = options.sampled;
+		this.pendingLinks = [...options.links];
+		this.pendingStatus = {
+			_tag: "Started",
+			startTime: options.startTime
+		};
+	}
+	get ids() {
+		if (this.provisional === void 0) {
+			const native = new Tracer.NativeSpan({
+				...this.options,
+				links: []
+			});
+			this.provisional = {
+				traceId: native.traceId,
+				spanId: native.spanId
+			};
+		}
+		return this.provisional;
+	}
+	get traceId() {
+		return this.real?.traceId ?? this.ids.traceId;
+	}
+	get spanId() {
+		return this.real?.spanId ?? this.ids.spanId;
+	}
+	get status() {
+		return this.real?.status ?? this.pendingStatus;
+	}
+	get attributes() {
+		return this.real?.attributes ?? this.pendingAttributes;
+	}
+	get links() {
+		return this.real?.links ?? this.pendingLinks;
+	}
+	end(endTime, exit) {
+		if (this.real !== void 0) return this.real.end(endTime, exit);
+		if (this.pendingStatus._tag === "Ended") return;
+		this.pendingStatus = {
+			_tag: "Ended",
+			startTime: this.pendingStatus.startTime,
+			endTime,
+			exit
+		};
+	}
+	attribute(key, value) {
+		if (this.real !== void 0) return this.real.attribute(key, value);
+		this.pendingAttributes.set(key, value);
+	}
+	event(name, startTime, attributes) {
+		if (this.real !== void 0) return this.real.event(name, startTime, attributes);
+		this.calls.push((span) => span.event(name, startTime, attributes));
+	}
+	addLinks(links) {
+		if (this.real !== void 0) return this.real.addLinks(links);
+		this.calls.push((span) => span.addLinks(links));
+	}
+	/** Opens the real span on `tracer` and replays onto it what happened so far. */
+	attach(tracer) {
+		const parent = Option.map(this.parent, (parent) => parent instanceof DeferredSpan ? parent.real ?? parent : parent);
+		const real = tracer.span({
+			...this.options,
+			parent,
+			links: this.pendingLinks
+		});
+		for (const [key, value] of this.pendingAttributes) real.attribute(key, value);
+		for (const call of this.calls) call(real);
+		if (this.pendingStatus._tag === "Ended") real.end(this.pendingStatus.endTime, this.pendingStatus.exit);
+		this.real = real;
+	}
+};
+/**
+* The Tracer a call starts under. A call's server span opens before `Live` is
+* built, and so before its Tracer is known, so that a first call's Layer
+* build nests under it. This Tracer defers the spans opened until then, and
+* {@link DeferredTracer.attach} hands them to the Tracer of `Live`, which
+* exports them with their original times and parents.
+*
+* @internal
+*/
+var DeferredTracer = class {
+	deferred = [];
+	held = [];
+	real;
+	/**
+	* Wraps each of `loggers` so that an entry logged before {@link attach}
+	* is held, and logged on `attach`, once the spans it was logged under have
+	* their real ids. A logger reads the trace of the current span, and a
+	* deferred span's ids before `attach` are ones no exporter sees.
+	*
+	* The tracer logger isn't held: it writes onto the span itself, which a
+	* deferred span already replays.
+	*/
+	holdLogs(loggers) {
+		return new Set(Array.from(loggers, (logger) => logger === Logger.tracerLogger ? logger : Logger.make((options) => {
+			if (this.real !== void 0) return logger.log(options);
+			const held = {
+				...options,
+				fiber: snapshot(options.fiber)
+			};
+			this.held.push(() => logger.log(held));
+		})));
+	}
+	tracer = Tracer.make({ span: (options) => {
+		if (this.real !== void 0) return this.real.span(options);
+		const span = new DeferredSpan(options);
+		this.deferred.push(span);
+		return span;
+	} });
+	/**
+	* Hands every span opened so far to the Tracer that `services` provide, the
+	* native one when they provide none, in the order they were opened, so that
+	* each parent exists before its children. Then logs the entries
+	* {@link holdLogs} held, in the order they were logged.
+	*
+	* Attach with no services when `Live` failed to build, so the spans and
+	* logs of the failed call still get ids of one trace.
+	*/
+	attach(services) {
+		if (this.real !== void 0) return;
+		this.real = Context.get(services, Tracer.Tracer);
+		for (const span of this.deferred) span.attach(this.real);
+		this.deferred.length = 0;
+		for (const log of this.held) log();
+		this.held.length = 0;
+	}
+};
+/**
+* `fiber` as it is now: what a logger reads from it later, such as the log
+* annotations and the current span, stays what it was when the entry was
+* logged. Both are derived from the fiber's context, which never changes in
+* place, only gets replaced.
+*/
+const snapshot = (fiber) => Object.create(fiber, {
+	context: { value: fiber.context },
+	cache: { value: fiber.cache }
+});
+export { DeferredTracer, externalParent };
+
+//# sourceMappingURL=serverSpan.mjs.map

package/dist/internal/serverSpan.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverSpan.mjs","names":[],"sources":["../../src/internal/serverSpan.ts"],"sourcesContent":["/** @internal */\nimport { Context, Logger, Option, Tracer, type Exit, type Fiber } from \"effect\";\nimport { traceContext } from \"firebase-functions/v2\";\n\n/**\n * The parent of a call's server span: the trace context `firebase-functions`\n * read from the request's headers, the `X-Cloud-Trace-Context` header winning\n * over `traceparent`. Read it synchronously at the start of the call, before\n * any fiber runs: Effect's scheduler may later run under another request's\n * async store. `undefined` when the request carried none, as in the emulator.\n *\n * @internal\n */\nexport const externalParent = (): Tracer.ExternalSpan | undefined => {\n  const store = traceContext.getStore();\n  if (store === undefined) return undefined;\n  return Tracer.externalSpan({\n    traceId: store.traceId,\n    // The Cloud header's decimal span id reaches us as unpadded hex.\n    spanId: store.parentId.padStart(16, \"0\"),\n    sampled: store.sample,\n  });\n};\n\ntype SpanOptions = Parameters<Tracer.Tracer[\"span\"]>[0];\n\n/**\n * A span opened before the Tracer of `Live` is known. It records what happens\n * to it, and replays that onto the real span once {@link DeferredTracer.attach}\n * creates it. From then on it forwards everything.\n */\nclass DeferredSpan implements Tracer.Span {\n  readonly _tag = \"Span\";\n  readonly name: string;\n  readonly parent: Option.Option<Tracer.AnySpan>;\n  readonly annotations: Context.Context<never>;\n  readonly kind: Tracer.SpanKind;\n  readonly sampled: boolean;\n  readonly options: SpanOptions;\n  real: Tracer.Span | undefined;\n  // What happened before `real` existed, in order.\n  private readonly calls: Array<(span: Tracer.Span) => void> = [];\n  private readonly pendingAttributes = new Map<string, unknown>();\n  private readonly pendingLinks: Array<Tracer.SpanLink>;\n  private pendingStatus: Tracer.SpanStatus;\n  private provisional: { traceId: string; spanId: string } | undefined;\n\n  constructor(options: SpanOptions) {\n    this.options = options;\n    this.name = options.name;\n    this.parent = options.parent;\n    this.annotations = options.annotations;\n    this.kind = options.kind;\n    this.sampled = options.sampled;\n    this.pendingLinks = [...options.links];\n    this.pendingStatus = { _tag: \"Started\", startTime: options.startTime };\n  }\n\n  // Read before `attach` only by a Tracer that `Live` provides to its own\n  // Layers: such a span joins the trace, but its parent's span id is one no\n  // exporter sees.\n  private get ids() {\n    if (this.provisional === undefined) {\n      const native = new Tracer.NativeSpan({ ...this.options, links: [] });\n      this.provisional = { traceId: native.traceId, spanId: native.spanId };\n    }\n    return this.provisional;\n  }\n\n  get traceId() {\n    return this.real?.traceId ?? this.ids.traceId;\n  }\n\n  get spanId() {\n    return this.real?.spanId ?? this.ids.spanId;\n  }\n\n  get status() {\n    return this.real?.status ?? this.pendingStatus;\n  }\n\n  get attributes() {\n    return this.real?.attributes ?? this.pendingAttributes;\n  }\n\n  get links() {\n    return this.real?.links ?? this.pendingLinks;\n  }\n\n  end(endTime: bigint, exit: Exit.Exit<unknown, unknown>) {\n    if (this.real !== undefined) return this.real.end(endTime, exit);\n    if (this.pendingStatus._tag === \"Ended\") return;\n    this.pendingStatus = { _tag: \"Ended\", startTime: this.pendingStatus.startTime, endTime, exit };\n  }\n\n  attribute(key: string, value: unknown) {\n    if (this.real !== undefined) return this.real.attribute(key, value);\n    this.pendingAttributes.set(key, value);\n  }\n\n  event(name: string, startTime: bigint, attributes?: Record<string, unknown>) {\n    if (this.real !== undefined) return this.real.event(name, startTime, attributes);\n    this.calls.push((span) => span.event(name, startTime, attributes));\n  }\n\n  addLinks(links: ReadonlyArray<Tracer.SpanLink>) {\n    if (this.real !== undefined) return this.real.addLinks(links);\n    this.calls.push((span) => span.addLinks(links));\n  }\n\n  /** Opens the real span on `tracer` and replays onto it what happened so far. */\n  attach(tracer: Tracer.Tracer) {\n    const parent = Option.map(this.parent, (parent) =>\n      parent instanceof DeferredSpan ? (parent.real ?? parent) : parent,\n    );\n    const real = tracer.span({ ...this.options, parent, links: this.pendingLinks });\n    for (const [key, value] of this.pendingAttributes) real.attribute(key, value);\n    for (const call of this.calls) call(real);\n    if (this.pendingStatus._tag === \"Ended\") {\n      real.end(this.pendingStatus.endTime, this.pendingStatus.exit);\n    }\n    this.real = real;\n  }\n}\n\n/**\n * The Tracer a call starts under. A call's server span opens before `Live` is\n * built, and so before its Tracer is known, so that a first call's Layer\n * build nests under it. This Tracer defers the spans opened until then, and\n * {@link DeferredTracer.attach} hands them to the Tracer of `Live`, which\n * exports them with their original times and parents.\n *\n * @internal\n */\nexport class DeferredTracer {\n  private readonly deferred: Array<DeferredSpan> = [];\n  private readonly held: Array<() => void> = [];\n  private real: Tracer.Tracer | undefined;\n\n  /**\n   * Wraps each of `loggers` so that an entry logged before {@link attach}\n   * is held, and logged on `attach`, once the spans it was logged under have\n   * their real ids. A logger reads the trace of the current span, and a\n   * deferred span's ids before `attach` are ones no exporter sees.\n   *\n   * The tracer logger isn't held: it writes onto the span itself, which a\n   * deferred span already replays.\n   */\n  holdLogs(\n    loggers: ReadonlySet<Logger.Logger<unknown, any>>,\n  ): ReadonlySet<Logger.Logger<unknown, any>> {\n    return new Set(\n      Array.from(loggers, (logger) =>\n        logger === Logger.tracerLogger\n          ? logger\n          : Logger.make<unknown, unknown>((options) => {\n              if (this.real !== undefined) return logger.log(options);\n              const held = { ...options, fiber: snapshot(options.fiber) };\n              this.held.push(() => logger.log(held));\n            }),\n      ),\n    );\n  }\n\n  readonly tracer: Tracer.Tracer = Tracer.make({\n    span: (options) => {\n      if (this.real !== undefined) return this.real.span(options);\n      const span = new DeferredSpan(options);\n      this.deferred.push(span);\n      return span;\n    },\n  });\n\n  /**\n   * Hands every span opened so far to the Tracer that `services` provide, the\n   * native one when they provide none, in the order they were opened, so that\n   * each parent exists before its children. Then logs the entries\n   * {@link holdLogs} held, in the order they were logged.\n   *\n   * Attach with no services when `Live` failed to build, so the spans and\n   * logs of the failed call still get ids of one trace.\n   */\n  attach(services: Context.Context<never>) {\n    if (this.real !== undefined) return;\n    this.real = Context.get(services, Tracer.Tracer);\n    for (const span of this.deferred) span.attach(this.real);\n    this.deferred.length = 0;\n    for (const log of this.held) log();\n    this.held.length = 0;\n  }\n}\n\n/**\n * `fiber` as it is now: what a logger reads from it later, such as the log\n * annotations and the current span, stays what it was when the entry was\n * logged. Both are derived from the fiber's context, which never changes in\n * place, only gets replaced.\n */\nconst snapshot = <A, E>(fiber: Fiber.Fiber<A, E>): Fiber.Fiber<A, E> =>\n  Object.create(fiber, {\n    context: { value: fiber.context },\n    cache: { value: fiber.cache },\n  }) as Fiber.Fiber<A, E>;\n"],"mappings":"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"}

package/dist/logger/CloudLogging.d.mts

@@ -0,0 +1,92 @@
+import { Layer, Logger } from "effect";
+declare namespace CloudLogging_d_exports {
+  export { layer, logger };
+}
+/**
+ * The Cloud Logging logger: writes each entry as one JSON line, the format
+ * Firebase's own `logger` writes, to `console.error` for Error and Fatal and
+ * to `console.log` for everything else.
+ *
+ * **When to use**
+ *
+ * Use with `Logger.layer` to combine it with other loggers. To replace
+ * Effect's default logger with it, use {@link layer}.
+ *
+ * **Details**
+ *
+ * Each entry is a JSON object with these fields:
+ *
+ * - `severity`: Trace and Debug are `DEBUG`, Info is `INFO`, Warn is
+ *   `WARNING`, Error is `ERROR` and Fatal is `CRITICAL`.
+ * - `message`: the first value logged. A non-empty Cause is appended as
+ *   `Cause.pretty` output, with its stacks, so Error Reporting picks up
+ *   defects.
+ * - `args`: the other values logged, if any.
+ * - `spans`: the log spans, as `{ label: milliseconds }`, if any.
+ * - `logging.googleapis.com/trace`, `logging.googleapis.com/spanId` and
+ *   `logging.googleapis.com/trace_sampled`: the trace of the fiber's current
+ *   span, with the project from `GCLOUD_PROJECT`, else `GOOGLE_CLOUD_PROJECT`.
+ *   Left out when there is no span, and when neither variable is set, since a
+ *   span id means nothing to Cloud Logging without its trace. Cloud Functions
+ *   sets `GCLOUD_PROJECT`.
+ * - Every log annotation, as a field of its own. `severity`, `message` and the
+ *   `logging.googleapis.com/` fields win over an annotation of the same name.
+ *
+ * The trace comes from the fiber, never from Firebase's `traceContext`, so
+ * concurrent requests on one instance each log under their own trace. Lines go
+ * to the `Console` service, which is the global `console` unless you provide
+ * another. Entries carry no uid: add one with `Effect.annotateLogs`.
+ *
+ * @example Logging under a uid
+ * ```ts
+ * import { Effect } from "effect";
+ * import { CloudLogging } from "@visiolab/effect-firebase-functions/logger";
+ *
+ * const program = Effect.log("Order placed").pipe(
+ *   Effect.annotateLogs({ uid: "user-1" }),
+ *   Effect.provide(CloudLogging.layer),
+ * );
+ * ```
+ *
+ * @see {@link layer} for replacing Effect's default logger with it
+ *
+ * @stability unstable
+ * @category loggers
+ * @since 0.3.0
+ */
+export declare const logger: Logger.Logger<unknown, void>;
+/**
+ * Replaces the current loggers with the Cloud Logging {@link logger} and
+ * Effect's `Logger.tracerLogger`, which records logs as span events.
+ *
+ * **When to use**
+ *
+ * Use to log as Cloud Logging entries outside a Function deployed with
+ * `Functions`, in any Effect program that runs on Google Cloud. Deployed
+ * Functions already log this way.
+ *
+ * **Details**
+ *
+ * Provided in the Layer of a deployed Function, it changes nothing. To log
+ * differently there, provide your own `Logger.layer`, which wins over this one.
+ *
+ * @example Logging from a scheduled job
+ * ```ts
+ * import { Effect } from "effect";
+ * import { CloudLogging } from "@visiolab/effect-firebase-functions/logger";
+ *
+ * const job = Effect.log("Cleaning up").pipe(
+ *   Effect.withSpan("cleanup"),
+ *   Effect.provide(CloudLogging.layer),
+ * );
+ * ```
+ *
+ * @see {@link logger} for the logger on its own
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.3.0
+ */
+export declare const layer: Layer.Layer<never>;
+export { CloudLogging_d_exports };
+//# sourceMappingURL=CloudLogging.d.mts.map

package/dist/logger/CloudLogging.mjs

@@ -0,0 +1,146 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { Cause, Console, Formatter, Inspectable, Logger, References } from "effect";
+// src/logger/CloudLogging.ts
+/**
+* A Logger that writes Effect logs as Cloud Logging structured entries, one
+* JSON line each, tied to the trace of the fiber's current span.
+*
+* `Functions` installs it for every call or event, beneath the Layer you
+* serve, so you need this module only to log the same way elsewhere, or to
+* change how a deployed Function logs.
+*
+* @stability unstable
+* @since 0.3.0
+*/
+var CloudLogging_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	logger: () => logger
+});
+const severities = {
+	All: "DEFAULT",
+	Trace: "DEBUG",
+	Debug: "DEBUG",
+	Info: "INFO",
+	Warn: "WARNING",
+	Error: "ERROR",
+	Fatal: "CRITICAL",
+	None: "DEFAULT"
+};
+/**
+* The Cloud Logging logger: writes each entry as one JSON line, the format
+* Firebase's own `logger` writes, to `console.error` for Error and Fatal and
+* to `console.log` for everything else.
+*
+* **When to use**
+*
+* Use with `Logger.layer` to combine it with other loggers. To replace
+* Effect's default logger with it, use {@link layer}.
+*
+* **Details**
+*
+* Each entry is a JSON object with these fields:
+*
+* - `severity`: Trace and Debug are `DEBUG`, Info is `INFO`, Warn is
+*   `WARNING`, Error is `ERROR` and Fatal is `CRITICAL`.
+* - `message`: the first value logged. A non-empty Cause is appended as
+*   `Cause.pretty` output, with its stacks, so Error Reporting picks up
+*   defects.
+* - `args`: the other values logged, if any.
+* - `spans`: the log spans, as `{ label: milliseconds }`, if any.
+* - `logging.googleapis.com/trace`, `logging.googleapis.com/spanId` and
+*   `logging.googleapis.com/trace_sampled`: the trace of the fiber's current
+*   span, with the project from `GCLOUD_PROJECT`, else `GOOGLE_CLOUD_PROJECT`.
+*   Left out when there is no span, and when neither variable is set, since a
+*   span id means nothing to Cloud Logging without its trace. Cloud Functions
+*   sets `GCLOUD_PROJECT`.
+* - Every log annotation, as a field of its own. `severity`, `message` and the
+*   `logging.googleapis.com/` fields win over an annotation of the same name.
+*
+* The trace comes from the fiber, never from Firebase's `traceContext`, so
+* concurrent requests on one instance each log under their own trace. Lines go
+* to the `Console` service, which is the global `console` unless you provide
+* another. Entries carry no uid: add one with `Effect.annotateLogs`.
+*
+* @example Logging under a uid
+* ```ts
+* import { Effect } from "effect";
+* import { CloudLogging } from "@visiolab/effect-firebase-functions/logger";
+*
+* const program = Effect.log("Order placed").pipe(
+*   Effect.annotateLogs({ uid: "user-1" }),
+*   Effect.provide(CloudLogging.layer),
+* );
+* ```
+*
+* @see {@link layer} for replacing Effect's default logger with it
+*
+* @stability unstable
+* @category loggers
+* @since 0.3.0
+*/
+const logger = Logger.make(({ cause, date, fiber, logLevel, message }) => {
+	const values = Array.isArray(message) ? message : [message];
+	const [first, ...args] = values;
+	let text = values.length === 0 ? "" : typeof first === "string" ? first : Inspectable.toStringUnknown(first);
+	if (cause.reasons.length > 0) {
+		const pretty = Cause.pretty(cause);
+		text = text === "" ? pretty : `${text}\n${pretty}`;
+	}
+	const entry = { ...fiber.getRef(References.CurrentLogAnnotations) };
+	if (args.length > 0) entry["args"] = args;
+	const logSpans = fiber.getRef(References.CurrentLogSpans);
+	if (logSpans.length > 0) {
+		const now = date.getTime();
+		entry["spans"] = Object.fromEntries(logSpans.map(([label, start]) => [label, now - start]));
+	}
+	for (const key of Object.keys(entry)) if (key.startsWith("logging.googleapis.com/")) delete entry[key];
+	entry["severity"] = severities[logLevel];
+	entry["message"] = text;
+	const span = fiber.cache.span;
+	const project = process.env["GCLOUD_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"];
+	if (span !== void 0 && project !== void 0 && project !== "") {
+		entry["logging.googleapis.com/trace"] = `projects/${project}/traces/${span.traceId}`;
+		entry["logging.googleapis.com/spanId"] = span.spanId;
+		entry["logging.googleapis.com/trace_sampled"] = span.sampled;
+	}
+	const console = fiber.getRef(Console.Console);
+	const line = Formatter.formatJson(entry);
+	if (logLevel === "Error" || logLevel === "Fatal") console.error(line);
+	else console.log(line);
+});
+/**
+* Replaces the current loggers with the Cloud Logging {@link logger} and
+* Effect's `Logger.tracerLogger`, which records logs as span events.
+*
+* **When to use**
+*
+* Use to log as Cloud Logging entries outside a Function deployed with
+* `Functions`, in any Effect program that runs on Google Cloud. Deployed
+* Functions already log this way.
+*
+* **Details**
+*
+* Provided in the Layer of a deployed Function, it changes nothing. To log
+* differently there, provide your own `Logger.layer`, which wins over this one.
+*
+* @example Logging from a scheduled job
+* ```ts
+* import { Effect } from "effect";
+* import { CloudLogging } from "@visiolab/effect-firebase-functions/logger";
+*
+* const job = Effect.log("Cleaning up").pipe(
+*   Effect.withSpan("cleanup"),
+*   Effect.provide(CloudLogging.layer),
+* );
+* ```
+*
+* @see {@link logger} for the logger on its own
+*
+* @stability unstable
+* @category layers
+* @since 0.3.0
+*/
+const layer = Logger.layer([logger, Logger.tracerLogger]);
+export { CloudLogging_exports, layer, logger };
+
+//# sourceMappingURL=CloudLogging.mjs.map

package/dist/logger/CloudLogging.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudLogging.mjs","names":[],"sources":["../../src/logger/CloudLogging.ts"],"sourcesContent":["/**\n * A Logger that writes Effect logs as Cloud Logging structured entries, one\n * JSON line each, tied to the trace of the fiber's current span.\n *\n * `Functions` installs it for every call or event, beneath the Layer you\n * serve, so you need this module only to log the same way elsewhere, or to\n * change how a deployed Function logs.\n *\n * @stability unstable\n * @since 0.3.0\n */\nimport { Cause, Console, Formatter, Inspectable, type Layer, Logger, References } from \"effect\";\nimport type * as LogLevel from \"effect/LogLevel\";\n\nconst severities: Record<LogLevel.LogLevel, string> = {\n  All: \"DEFAULT\",\n  Trace: \"DEBUG\",\n  Debug: \"DEBUG\",\n  Info: \"INFO\",\n  Warn: \"WARNING\",\n  Error: \"ERROR\",\n  Fatal: \"CRITICAL\",\n  None: \"DEFAULT\",\n};\n\n/**\n * The Cloud Logging logger: writes each entry as one JSON line, the format\n * Firebase's own `logger` writes, to `console.error` for Error and Fatal and\n * to `console.log` for everything else.\n *\n * **When to use**\n *\n * Use with `Logger.layer` to combine it with other loggers. To replace\n * Effect's default logger with it, use {@link layer}.\n *\n * **Details**\n *\n * Each entry is a JSON object with these fields:\n *\n * - `severity`: Trace and Debug are `DEBUG`, Info is `INFO`, Warn is\n *   `WARNING`, Error is `ERROR` and Fatal is `CRITICAL`.\n * - `message`: the first value logged. A non-empty Cause is appended as\n *   `Cause.pretty` output, with its stacks, so Error Reporting picks up\n *   defects.\n * - `args`: the other values logged, if any.\n * - `spans`: the log spans, as `{ label: milliseconds }`, if any.\n * - `logging.googleapis.com/trace`, `logging.googleapis.com/spanId` and\n *   `logging.googleapis.com/trace_sampled`: the trace of the fiber's current\n *   span, with the project from `GCLOUD_PROJECT`, else `GOOGLE_CLOUD_PROJECT`.\n *   Left out when there is no span, and when neither variable is set, since a\n *   span id means nothing to Cloud Logging without its trace. Cloud Functions\n *   sets `GCLOUD_PROJECT`.\n * - Every log annotation, as a field of its own. `severity`, `message` and the\n *   `logging.googleapis.com/` fields win over an annotation of the same name.\n *\n * The trace comes from the fiber, never from Firebase's `traceContext`, so\n * concurrent requests on one instance each log under their own trace. Lines go\n * to the `Console` service, which is the global `console` unless you provide\n * another. Entries carry no uid: add one with `Effect.annotateLogs`.\n *\n * @example Logging under a uid\n * ```ts\n * import { Effect } from \"effect\";\n * import { CloudLogging } from \"@visiolab/effect-firebase-functions/logger\";\n *\n * const program = Effect.log(\"Order placed\").pipe(\n *   Effect.annotateLogs({ uid: \"user-1\" }),\n *   Effect.provide(CloudLogging.layer),\n * );\n * ```\n *\n * @see {@link layer} for replacing Effect's default logger with it\n *\n * @stability unstable\n * @category loggers\n * @since 0.3.0\n */\nexport const logger: Logger.Logger<unknown, void> = Logger.make(\n  ({ cause, date, fiber, logLevel, message }) => {\n    const values = Array.isArray(message) ? message : [message];\n    const [first, ...args] = values;\n    let text =\n      values.length === 0\n        ? \"\"\n        : typeof first === \"string\"\n          ? first\n          : Inspectable.toStringUnknown(first);\n    if (cause.reasons.length > 0) {\n      const pretty = Cause.pretty(cause);\n      text = text === \"\" ? pretty : `${text}\\n${pretty}`;\n    }\n\n    const entry: Record<string, unknown> = { ...fiber.getRef(References.CurrentLogAnnotations) };\n    if (args.length > 0) entry[\"args\"] = args;\n    const logSpans = fiber.getRef(References.CurrentLogSpans);\n    if (logSpans.length > 0) {\n      const now = date.getTime();\n      entry[\"spans\"] = Object.fromEntries(logSpans.map(([label, start]) => [label, now - start]));\n    }\n    for (const key of Object.keys(entry)) {\n      if (key.startsWith(\"logging.googleapis.com/\")) delete entry[key];\n    }\n    entry[\"severity\"] = severities[logLevel];\n    entry[\"message\"] = text;\n    const span = fiber.cache.span;\n    const project = process.env[\"GCLOUD_PROJECT\"] ?? process.env[\"GOOGLE_CLOUD_PROJECT\"];\n    if (span !== undefined && project !== undefined && project !== \"\") {\n      entry[\"logging.googleapis.com/trace\"] = `projects/${project}/traces/${span.traceId}`;\n      entry[\"logging.googleapis.com/spanId\"] = span.spanId;\n      entry[\"logging.googleapis.com/trace_sampled\"] = span.sampled;\n    }\n\n    const console = fiber.getRef(Console.Console);\n    const line = Formatter.formatJson(entry);\n    if (logLevel === \"Error\" || logLevel === \"Fatal\") console.error(line);\n    else console.log(line);\n  },\n);\n\n/**\n * Replaces the current loggers with the Cloud Logging {@link logger} and\n * Effect's `Logger.tracerLogger`, which records logs as span events.\n *\n * **When to use**\n *\n * Use to log as Cloud Logging entries outside a Function deployed with\n * `Functions`, in any Effect program that runs on Google Cloud. Deployed\n * Functions already log this way.\n *\n * **Details**\n *\n * Provided in the Layer of a deployed Function, it changes nothing. To log\n * differently there, provide your own `Logger.layer`, which wins over this one.\n *\n * @example Logging from a scheduled job\n * ```ts\n * import { Effect } from \"effect\";\n * import { CloudLogging } from \"@visiolab/effect-firebase-functions/logger\";\n *\n * const job = Effect.log(\"Cleaning up\").pipe(\n *   Effect.withSpan(\"cleanup\"),\n *   Effect.provide(CloudLogging.layer),\n * );\n * ```\n *\n * @see {@link logger} for the logger on its own\n *\n * @stability unstable\n * @category layers\n * @since 0.3.0\n */\nexport const layer: Layer.Layer<never> = Logger.layer([logger, Logger.tracerLogger]);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAcA,MAAM,aAAgD;CACpD,KAAK;CACL,OAAO;CACP,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACP,OAAO;CACP,MAAM;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,SAAuC,OAAO,MACxD,EAAE,OAAO,MAAM,OAAO,UAAU,cAAc;CAC7C,MAAM,SAAS,MAAM,QAAQ,OAAO,IAAI,UAAU,CAAC,OAAO;CAC1D,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,IAAI,OACF,OAAO,WAAW,IACd,KACA,OAAO,UAAU,WACf,QACA,YAAY,gBAAgB,KAAK;CACzC,IAAI,MAAM,QAAQ,SAAS,GAAG;EAC5B,MAAM,SAAS,MAAM,OAAO,KAAK;EACjC,OAAO,SAAS,KAAK,SAAS,GAAG,KAAK,IAAI;CAC5C;CAEA,MAAM,QAAiC,EAAE,GAAG,MAAM,OAAO,WAAW,qBAAqB,EAAE;CAC3F,IAAI,KAAK,SAAS,GAAG,MAAM,UAAU;CACrC,MAAM,WAAW,MAAM,OAAO,WAAW,eAAe;CACxD,IAAI,SAAS,SAAS,GAAG;EACvB,MAAM,MAAM,KAAK,QAAQ;EACzB,MAAM,WAAW,OAAO,YAAY,SAAS,KAAK,CAAC,OAAO,WAAW,CAAC,OAAO,MAAM,KAAK,CAAC,CAAC;CAC5F;CACA,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GACjC,IAAI,IAAI,WAAW,yBAAyB,GAAG,OAAO,MAAM;CAE9D,MAAM,cAAc,WAAW;CAC/B,MAAM,aAAa;CACnB,MAAM,OAAO,MAAM,MAAM;CACzB,MAAM,UAAU,QAAQ,IAAI,qBAAqB,QAAQ,IAAI;CAC7D,IAAI,SAAS,KAAA,KAAa,YAAY,KAAA,KAAa,YAAY,IAAI;EACjE,MAAM,kCAAkC,YAAY,QAAQ,UAAU,KAAK;EAC3E,MAAM,mCAAmC,KAAK;EAC9C,MAAM,0CAA0C,KAAK;CACvD;CAEA,MAAM,UAAU,MAAM,OAAO,QAAQ,OAAO;CAC5C,MAAM,OAAO,UAAU,WAAW,KAAK;CACvC,IAAI,aAAa,WAAW,aAAa,SAAS,QAAQ,MAAM,IAAI;MAC/D,QAAQ,IAAI,IAAI;AACvB,CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,QAA4B,OAAO,MAAM,CAAC,QAAQ,OAAO,YAAY,CAAC"}

package/dist/logger/index.d.mts

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

package/dist/logger/index.mjs

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

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@visiolab/effect-firebase-functions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.1",
+  "description": "Cloud Functions for Firebase deployment of the @visiolab/effect-firebase Functions.",
+  "keywords": [
+    "effect",
+    "firebase",
+    "firebase-functions",
+    "typescript"
+  ],
+  "homepage": "https://visiolab.github.io/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/functions"
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist/**/*.mjs",
+    "dist/**/*.mjs.map",
+    "dist/**/*.d.mts",
+    "dist/**/*.d.mts.map"
+  ],
+  "type": "module",
+  "sideEffects": [],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./Functions": "./dist/Functions.mjs",
+    "./logger": "./dist/logger/index.mjs",
+    "./logger/CloudLogging": "./dist/logger/CloudLogging.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^4.1.0",
+    "effect": "4.1.0",
+    "firebase": "^13.0.0",
+    "firebase-admin": "^14.5.0",
+    "firebase-functions": "^7.4.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-admin": "^0.3.1",
+    "@visiolab/effect-firebase": "^0.3.1"
+  },
+  "peerDependencies": {
+    "effect": "~4.1.0",
+    "firebase-admin": "^14.5.0",
+    "firebase-functions": "^7.4.0",
+    "@visiolab/effect-firebase": "^0.3.1",
+    "@visiolab/effect-firebase-admin": "^0.3.1"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "build-fixture": "vp -C tests/fixture pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
 }