better-supabase 0.3.0 → 0.5.0

package/dist/edge/index.d.ts

@@ -1,7 +1,7 @@
-import { N as TableKey, n as AnyModels, t as AnyFunctions } from "../types-DONv9SHN.js";
-import { t as BetterSupabase } from "../define-DUbydmJa.js";
-import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-DAkPIdTH.js";
-import { a as ResourceRouteOptions } from "../resource-CwVgiI5q.js";
+import { P as TableKey, n as AnyFunctions, r as AnyModels } from "../types-Dnf_wRDz.js";
+import { t as BetterSupabase } from "../define-Bp_BZa5h.js";
+import { f as ServerContext, n as GuardOptions, p as ServerOptions, r as MiddlewareOptions, u as BetterServer } from "../respond-D2OQl62-.js";
+import { a as ResourceRouteOptions } from "../resource-D8iqWMr-.js";
 //#region src/edge/index.d.ts
 export interface CorsOptions {
   /** Allowed origins, or `*`. Defaults to `*`. */
@@ -16,28 +16,35 @@ export interface EdgeOptions extends ServerOptions {
   readonly cors?: boolean | CorsOptions;
   /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
   readonly exposeErrors?: boolean;
+  /**
+   * Keeps the invocation alive for event sink sends a handler started, e.g.
+   * `EdgeRuntime.waitUntil` on Supabase. On Workers the `ctx` the runtime
+   * passes to `fetch` is used when this is unset.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
 }
-export interface HandlerOptions extends GuardOptions {
-  /** Refresh an expired cookie session and send the new cookies. */
-  readonly refresh?: boolean;
+/** The platform context Workers pass as the third `fetch` argument. */
+export interface EdgeExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
 }
-export type EdgeHandler = (request: Request) => Promise<Response>;
+/** `Deno.serve` passes `(request, info)`, Workers `fetch` passes `(request, env, ctx)`. */
+export type EdgeHandler = (request: Request, env?: unknown, executionContext?: EdgeExecutionContext) => Promise<Response>;
 export type ResourceMap<M extends AnyModels> = { readonly [T in TableKey<M>]?: ResourceRouteOptions<M, T> | true; };
-export interface ResourcesOptions extends HandlerOptions {
+export interface ResourcesOptions extends MiddlewareOptions {
   /** Path before the resources, e.g. `/api` (Supabase: `/<function-name>`). */
   readonly basePath?: string;
 }
-export interface BetterEdge<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+export interface BetterEdge<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
   /**
    * A fetch handler (`Deno.serve`, Workers `fetch`) running as the caller.
    * `Result`s become JSON or Problem Details; `undefined` becomes 204.
    */
-  handler(fn: (request: Request, ctx: ServerContext<M, F, E>) => unknown, options?: HandlerOptions): EdgeHandler;
+  handler(fn: (request: Request, ctx: ServerContext<M, F, E, C, P>) => unknown, options?: MiddlewareOptions): EdgeHandler;
   /** REST resources matching `createOpenApi`, e.g. `Deno.serve(bs.resources({ customers: true }))`. */
   resources(map: ResourceMap<M>, options?: ResourcesOptions): EdgeHandler;
 }
 export declare const SUPABASE_CORS_HEADERS: readonly string[];
 /** Fetch-handler integration for Supabase Edge Functions, Deno, Bun and Workers. */
-export declare function createEdge<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options?: EdgeOptions): BetterEdge<M, F, E>;
+export declare function createEdge<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: EdgeOptions): BetterEdge<M, F, E, C, P>;
 //#endregion
-export type { GuardOptions, ResourceRouteOptions };
+export type { GuardOptions, MiddlewareOptions, ResourceRouteOptions };

package/dist/edge/index.js

@@ -1,7 +1,7 @@
-import { n as dbError } from "../errors-Bl3rkOzo.js";
-import { a as problemResponse } from "../problem-CGt1ADix.js";
-import { i as respond, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-C44EZAJo.js";
-import { t as defineResource } from "../resource-D30rp0GN.js";
+import { n as dbError } from "../errors-DtwXa6b8.js";
+import { a as problemResponse } from "../problem-BW1KhzSG.js";
+import { d as guard, n as createServer, p as respond, r as extendServer, u as defaultExpose } from "../server-Csx2sRjg.js";
+import { t as defineResource } from "../resource-CRxxwkQq.js";
 //#region src/edge/index.ts
 const SUPABASE_CORS_HEADERS = [
 	"authorization",
@@ -9,15 +9,11 @@ const SUPABASE_CORS_HEADERS = [
 	"apikey",
 	"content-type"
 ];
-function corsHeaders(request, cors) {
-	const origin = request.headers.get("origin");
+/** The CORS headers for a request's origin; the fixed ones are joined once. */
+function corsFor(cors) {
 	const allowed = cors.origin ?? "*";
-	let value;
-	if (allowed === "*") value = "*";
-	else if (origin && (typeof allowed === "string" ? [allowed] : allowed).includes(origin)) value = origin;
-	if (!value) return void 0;
-	return {
-		"access-control-allow-origin": value,
+	const origins = new Set(typeof allowed === "string" ? [allowed] : allowed);
+	const fixed = {
 		"access-control-allow-headers": (cors.headers ?? SUPABASE_CORS_HEADERS).join(", "),
 		"access-control-allow-methods": (cors.methods ?? [
 			"GET",
@@ -26,8 +22,21 @@ function corsHeaders(request, cors) {
 			"DELETE",
 			"OPTIONS"
 		]).join(", "),
-		...cors.maxAge === void 0 ? {} : { "access-control-max-age": String(cors.maxAge) },
-		...value === "*" ? {} : { vary: "origin" }
+		...cors.maxAge === void 0 ? {} : { "access-control-max-age": String(cors.maxAge) }
+	};
+	const any = {
+		"access-control-allow-origin": "*",
+		...fixed
+	};
+	return (request) => {
+		if (allowed === "*") return any;
+		const origin = request.headers.get("origin");
+		if (!origin || !origins.has(origin)) return;
+		return {
+			"access-control-allow-origin": origin,
+			...fixed,
+			vary: "origin"
+		};
 	};
 }
 function withHeaders(response, headers) {
@@ -41,17 +50,20 @@ function withHeaders(response, headers) {
 	return target;
 }
 /** Fetch-handler integration for Supabase Edge Functions, Deno, Bun and Workers. */
-function createEdge(sb, options = {}) {
-	const server = createServer(sb, options);
+function createEdge(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
 	const expose = options.exposeErrors ?? defaultExpose();
 	const cors = options.cors === true ? {} : options.cors === false ? void 0 : options.cors;
-	const serve = (run, handlerOptions) => {
-		return async (request) => {
-			const extra = cors ? corsHeaders(request, cors) : void 0;
+	const corsHeaders = cors ? corsFor(cors) : void 0;
+	const serve = (run, handlerOptions, early) => {
+		return async (request, _env, executionContext) => {
+			const extra = corsHeaders?.(request);
 			if (cors && request.method === "OPTIONS") return new Response(null, {
 				status: 204,
 				headers: extra ?? {}
 			});
+			const answered = early?.(request);
+			if (answered) return extra ? withHeaders(answered, extra) : answered;
 			const ctx = await server.context(request, { refresh: handlerOptions.refresh ?? false });
 			const instance = new URL(request.url).pathname;
 			const denied = guard(ctx.auth, handlerOptions.allow, handlerOptions.aal, handlerOptions.scopes);
@@ -67,7 +79,10 @@ function createEdge(sb, options = {}) {
 					expose
 				});
 			}
-			response = ctx.resolution.apply(response);
+			response = ctx.apply(response);
+			const { events } = betterSupabase;
+			const waitUntil = options.waitUntil ?? executionContext?.waitUntil.bind(executionContext);
+			if (events.pending && waitUntil) waitUntil(events.settled());
 			return extra ? withHeaders(response, extra) : response;
 		};
 	};
@@ -83,19 +98,33 @@ function createEdge(sb, options = {}) {
 			const handlers = /* @__PURE__ */ new Map();
 			for (const [table, resource] of Object.entries(map)) {
 				if (!resource) continue;
-				handlers.set(table, defineResource(sb, table, resource === true ? {} : resource));
+				handlers.set(table, defineResource(betterSupabase, table, resource === true ? {} : resource));
 			}
-			return serve(async (request, ctx) => {
+			const routes = /* @__PURE__ */ new WeakMap();
+			const notFound = (request) => {
 				const { pathname } = new URL(request.url);
-				const instance = pathname;
 				const [table, id, extra] = (pathname.startsWith(`${base}/`) ? pathname.slice(base.length + 1) : void 0)?.split("/") ?? [];
 				const handler = table ? handlers.get(table) : void 0;
-				if (!handler || extra !== void 0 || id !== void 0 && !handler.keyParam) return problemResponse(dbError("not_found", `No route for ${pathname}`), { instance });
-				return handler.handle(request, ctx.db, id === void 0 || id === "" ? void 0 : decodeURIComponent(id), {
+				if (!handler || extra !== void 0 || id !== void 0 && !handler.keyParam) return problemResponse(dbError("not_found", `No route for ${pathname}`), { instance: pathname });
+				let key;
+				try {
+					key = id === void 0 || id === "" ? void 0 : decodeURIComponent(id);
+				} catch {
+					return problemResponse(dbError("invalid_input", `Malformed id in ${pathname}`), { instance: pathname });
+				}
+				routes.set(request, {
+					handler,
+					id: key,
+					instance: pathname
+				});
+			};
+			return serve((request, ctx) => {
+				const { handler, id, instance } = routes.get(request);
+				return handler.handle(request, ctx.db, id, {
 					instance,
 					expose
 				});
-			}, resourcesOptions);
+			}, resourcesOptions, notFound);
 		}
 	});
 }

package/dist/{entitlements-DvJXoI02.d.ts → entitlements-DUxU4oHe.d.ts}

@@ -1,4 +1,4 @@
-import { t as AuthSession } from "./view-3Po_PVlr.js";
+import { t as AuthSession } from "./view-BEf0diC5.js";
 //#region src/auth/entitlements.d.ts
 /**
  * One entry of the `memberships` claim, in PermDock's shape. PermDock strips
@@ -25,7 +25,7 @@ interface MembershipClaim {
 }
 /**
  * Entitlement keys of the `features` claim: the literal union when
- * `sb.claims(schema)` declares one (`z.enum([...])`), otherwise `string`.
+ * `betterSupabase.claims(schema)` declares one (`z.enum([...])`), otherwise `string`.
  */
 type EntitlementKey<C> = C extends {
   readonly features?: infer F;

package/dist/env/index.d.ts

@@ -1,2 +1,2 @@
-import { a as EnvResult, c as PublicEnv, d as parseEnv, f as publicEnv, i as EnvOptions, l as envSchema, n as ENV_VARIABLES, o as EnvSource, p as toServerEnv, r as EnvIssue, s as EnvValidationError, t as BetterSupabaseEnv, u as loadEnv } from "../index-Dy6kuF0P.js";
-export { BetterSupabaseEnv, ENV_VARIABLES, EnvIssue, EnvOptions, EnvResult, EnvSource, EnvValidationError, PublicEnv, envSchema, loadEnv, parseEnv, publicEnv, toServerEnv };
+import { a as EnvResult, c as InlineJwks, d as loadEnv, f as parseEnv, i as EnvOptions, l as PublicEnv, m as toServerEnv, n as ENV_VARIABLES, o as EnvSource, p as publicEnv, r as EnvIssue, s as EnvValidationError, t as BetterSupabaseEnv, u as envSchema } from "../index-CLg87OBW.js";
+export { BetterSupabaseEnv, ENV_VARIABLES, EnvIssue, EnvOptions, EnvResult, EnvSource, EnvValidationError, InlineJwks, PublicEnv, envSchema, loadEnv, parseEnv, publicEnv, toServerEnv };

package/dist/env/index.js

@@ -13,6 +13,7 @@ const ENV_VARIABLES = {
 	secretKey: ["SUPABASE_SECRET_KEY"],
 	dbUrl: ["SUPABASE_DB_URL", "DATABASE_URL"],
 	jwksUrl: ["SUPABASE_JWKS_URL"],
+	jwks: ["SUPABASE_JWKS"],
 	readUrl: ["SUPABASE_READ_URL"]
 };
 const LOOPBACK = /^(localhost|127(?:\.\d{1,3}){3}|\[::1\])$/;
@@ -57,6 +58,35 @@ function preferred(keys) {
 	if (!keys) return void 0;
 	return keys["default"] ?? Object.values(keys)[0];
 }
+function isJwk(value) {
+	return typeof value === "object" && value !== null && "kty" in value && typeof value.kty === "string";
+}
+/** At least one key, each an object with a string `kty`, the shape the verifier reads. */
+function isJwkList(value) {
+	return Array.isArray(value) && value.length > 0 && value.every(isJwk);
+}
+/** `SUPABASE_JWKS` as `@supabase/server` reads it: `{"keys":[...]}` or `[...]`. */
+function checkJwks(raw, issues) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		issues.push({
+			variables: ENV_VARIABLES.jwks,
+			message: "must be JSON: {\"keys\":[...]} or [...]"
+		});
+		return;
+	}
+	const keys = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? "keys" in parsed ? parsed.keys : void 0 : parsed;
+	if (!isJwkList(keys)) {
+		issues.push({
+			variables: ENV_VARIABLES.jwks,
+			message: "must hold at least one JSON Web Key with a kty"
+		});
+		return;
+	}
+	return { keys };
+}
 function checkUrl(value, variables, issues) {
 	let url;
 	try {
@@ -132,6 +162,8 @@ function parseEnv(source, options = {}) {
 	});
 	const rawJwks = first(source, ENV_VARIABLES.jwksUrl);
 	const jwksOverride = rawJwks ? checkUrl(rawJwks, ENV_VARIABLES.jwksUrl, issues) : void 0;
+	const rawInline = first(source, ENV_VARIABLES.jwks);
+	const jwks = rawInline ? checkJwks(rawInline, issues) : void 0;
 	const rawRead = first(source, ENV_VARIABLES.readUrl);
 	const readUrl = rawRead ? checkUrl(rawRead, ENV_VARIABLES.readUrl, issues) : void 0;
 	if (issues.length > 0 || !url || !publishableKey) return {
@@ -146,6 +178,7 @@ function parseEnv(source, options = {}) {
 			url: base,
 			publishableKey,
 			jwksUrl: jwksOverride ?? new URL(`${base}/auth/v1/.well-known/jwks.json`),
+			...jwks ? { jwks } : {},
 			...secretKey ? {
 				secretKey,
 				secretKeys: {
@@ -197,7 +230,7 @@ function toServerEnv(env) {
 		url: env.url,
 		publishableKeys: { default: env.publishableKey },
 		secretKeys: env.secretKeys ?? (env.secretKey ? { default: env.secretKey } : {}),
-		jwks: env.jwksUrl
+		jwks: env.jwks ?? env.jwksUrl
 	};
 }
 //#endregion

package/dist/{errors-Bl3rkOzo.js → errors-DtwXa6b8.js}

@@ -9,6 +9,7 @@ const STATUS = {
 	not_null: 422,
 	exclusion: 409,
 	invalid_input: 400,
+	invalid_value: 500,
 	raised: 400,
 	timeout: 504,
 	serialization: 409,
@@ -41,7 +42,7 @@ function isDbError(value) {
 }
 /**
 * The `DbError` in a `DbError`, a `DbException`, or an error whose `cause`
-* is a `DbError` (what `sb.mapError()` mappers should set).
+* is a `DbError` (what `betterSupabase.mapError()` mappers should set).
 */
 function dbErrorOf(value) {
 	if (value instanceof DbException) return value.error;

package/dist/events/index.d.ts

@@ -1,2 +1,3 @@
-import { a as HttpMode, c as RowEventData, d as httpSink, f as isCloudEvent, i as ForwardOptions, l as forwardMutations, m as toHttp, n as CloudEventOptions, o as HttpSinkOptions, p as toCloudEvents, r as EventSink, s as ROW_EVENT_TYPES, t as CloudEvent, u as fromHttp } from "../index-GV77NpRP.js";
-export { CloudEvent, CloudEventOptions, EventSink, ForwardOptions, HttpMode, HttpSinkOptions, ROW_EVENT_TYPES, RowEventData, forwardMutations, fromHttp, httpSink, isCloudEvent, toCloudEvents, toHttp };
+import { C as kitEventAttributes, S as WebhookEventData, _ as KitEventType, b as OrgEventData, d as InvitationEventData, f as KIT_ATTRIBUTES, g as KitEventPattern, h as KitEventMeta, m as KitEventMap, p as KitEvent, v as KitEventsMatching, w as onKitEvent, x as SupportEventData, y as NotificationEventData } from "../events-aIO7vsIk.js";
+import { _ as toHttp, a as ForwardOptions, c as ROW_EVENT_TYPES, d as forwardMutations, f as fromHttp, g as toCloudEvents, h as kitCloudEvent, i as ForwardKitOptions, l as RowEventData, m as isCloudEvent, n as CloudEventOptions, o as HttpMode, p as httpSink, r as EventSink, s as HttpSinkOptions, t as CloudEvent, u as forwardKitEvents } from "../index-DOESKG27.js";
+export { CloudEvent, CloudEventOptions, EventSink, ForwardKitOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InvitationEventData, KIT_ATTRIBUTES, type KitEvent, type KitEventMap, type KitEventMeta, type KitEventPattern, type KitEventType, type KitEventsMatching, type NotificationEventData, type OrgEventData, ROW_EVENT_TYPES, RowEventData, type SupportEventData, type WebhookEventData, forwardKitEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, kitCloudEvent, kitEventAttributes, onKitEvent, toCloudEvents, toHttp };

package/dist/events/index.js

@@ -1,10 +1,12 @@
-import { n as nowInstant } from "../temporal-BwshQk0W.js";
+import { n as nowInstant } from "../temporal-CVlIV2DZ.js";
+import { i as onKitEvent, r as kitEventAttributes, t as KIT_ATTRIBUTES } from "../kit-events-CTFDfSwb.js";
 //#region src/events/index.ts
 const ROW_EVENT_TYPES = {
 	insert: "dev.better-supabase.row.created",
 	upsert: "dev.better-supabase.row.upserted",
 	update: "dev.better-supabase.row.updated",
-	delete: "dev.better-supabase.row.deleted"
+	delete: "dev.better-supabase.row.deleted",
+	softDelete: "dev.better-supabase.row.softdeleted"
 };
 function subjectOf(meta, table, row) {
 	const key = meta?.tables[table]?.primaryKey;
@@ -15,13 +17,19 @@ function subjectOf(meta, table, row) {
 }
 /**
 * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
-* app-cased row as `data`, the primary key as `subject`, the tenant as
-* `partitionkey` and the actor as `actorid`.
+* app-cased row and the actor in `data`, the primary key as `subject` and the
+* tenant as `partitionkey`. Writes that return no rows (soft
+* deletes, `returning: false`) send one event per known primary key, with the
+* key as `row`.
 */
 function toCloudEvents(notice, options) {
-	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[notice.kind].split(".").at(-1)}` : ROW_EVENT_TYPES[notice.kind];
+	const intent = notice.intent ?? notice.kind;
+	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[intent].split(".").at(-1)}` : ROW_EVENT_TYPES[intent];
 	const time = (options.now ?? nowInstant)().toString();
-	return notice.rows.map((row) => {
+	const tenant = notice.tenant ?? notice.context.tenant;
+	const rows = notice.rows.length > 0 ? notice.rows : notice.keys ?? [];
+	const actorId = notice.context.actor?.id;
+	return rows.map((row) => {
 		const subject = subjectOf(options.meta, notice.table, row);
 		return {
 			specversion: "1.0",
@@ -33,32 +41,77 @@ function toCloudEvents(notice, options) {
 			datacontenttype: "application/json",
 			data: {
 				table: notice.table,
-				row
+				row,
+				...actorId ? { actorId } : {}
 			},
-			...notice.context.tenant ? { partitionkey: notice.context.tenant } : {},
-			...notice.context.actor?.id ? { actorid: notice.context.actor.id } : {}
+			...tenant ? { partitionkey: tenant } : {}
 		};
 	});
 }
 /**
 * Sends a CloudEvent for every mutation to `sink`. Returns a function that
-* stops forwarding. Use an outbox (SQL kit) when events must not be lost.
+* stops forwarding. Sends in flight are tracked on `betterSupabase.events`
+* (`settled()`), which the Next adapter hands to `after()` and the edge
+* entry to `waitUntil`. Use an outbox (SQL kit) when events must not be lost.
 */
-function forwardMutations(sb, sink, options) {
-	return sb.events.on("mutation", (notice) => {
+function forwardMutations(betterSupabase, sink, options) {
+	return betterSupabase.events.on("mutation", (notice) => {
 		if (options.filter && !options.filter(notice)) return;
 		const events = toCloudEvents(notice, {
 			...options,
-			meta: sb.meta
+			meta: betterSupabase.meta
 		});
 		if (events.length === 0) return;
 		const report = (error) => {
 			(options.onError ?? ((cause) => {
-				sb.events.logger.error("event sink failed", { cause });
+				betterSupabase.events.logger.error("event sink failed", { cause });
 			}))(error, events);
 		};
 		try {
-			Promise.resolve(sink.send(events)).catch(report);
+			betterSupabase.events.track(Promise.resolve(sink.send(events)).catch(report));
+		} catch (error) {
+			report(error);
+		}
+	});
+}
+/**
+* A kit event as a CloudEvent: `dev.better-supabase.support.started` with
+* the event data and the actor (`actorId`) as `data` and the tenant as
+* `partitionkey`.
+*/
+function kitCloudEvent(event, options) {
+	return {
+		specversion: "1.0",
+		id: options.id?.() ?? crypto.randomUUID(),
+		source: options.source,
+		type: `${options.typePrefix ?? "dev.better-supabase"}.${event.type}`,
+		...event.subject ? { subject: event.subject } : {},
+		time: (options.now?.() ?? event.time).toString(),
+		datacontenttype: "application/json",
+		data: event.actorId ? {
+			...event.data,
+			actorId: event.actorId
+		} : event.data,
+		...event.tenant ? { partitionkey: event.tenant } : {}
+	};
+}
+/**
+* Sends a CloudEvent for every kit event (`support.*`, `org.*`, ...) to
+* `sink`. Returns a function that stops forwarding. Like
+* `forwardMutations`, sends are tracked on `betterSupabase.events`.
+*/
+function forwardKitEvents(betterSupabase, sink, options) {
+	const types = options.types;
+	return betterSupabase.events.on("kit", (event) => {
+		if (types && !types.some((pattern) => pattern.endsWith(".*") ? event.type.startsWith(pattern.slice(0, -1)) : pattern === event.type)) return;
+		const events = [kitCloudEvent(event, options)];
+		const report = (error) => {
+			(options.onError ?? ((cause) => {
+				betterSupabase.events.logger.error("event sink failed", { cause });
+			}))(error, events);
+		};
+		try {
+			betterSupabase.events.track(Promise.resolve(sink.send(events)).catch(report));
 		} catch (error) {
 			report(error);
 		}
@@ -137,4 +190,4 @@ function httpSink(url, options = {}) {
 	} };
 }
 //#endregion
-export { ROW_EVENT_TYPES, forwardMutations, fromHttp, httpSink, isCloudEvent, toCloudEvents, toHttp };
+export { KIT_ATTRIBUTES, ROW_EVENT_TYPES, forwardKitEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, kitCloudEvent, kitEventAttributes, onKitEvent, toCloudEvents, toHttp };