effect-inngest 0.1.0

package/dist/Client.js

@@ -0,0 +1,144 @@
+import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { Headers } from "./internal/protocol.js";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Config from "effect/Config";
+import * as Predicate from "effect/Predicate";
+
+//#region src/Client.ts
+/**
+* @since 0.1.0
+*/
+var Client_exports = /* @__PURE__ */ __exportAll({
+	EventPayload: () => EventPayload,
+	InngestClient: () => InngestClient,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	layerFromEnv: () => layerFromEnv
+});
+/**
+* @since 0.1.0
+* @category type ids
+* @internal
+*/
+const TypeId = Symbol.for("effect-inngest/Client");
+const DEFAULT_EVENT_BASE_URL = "https://inn.gs/";
+const DEFAULT_API_BASE_URL = "https://api.inngest.com/";
+const DEFAULT_DEV_SERVER_URL = "http://localhost:8288/";
+const SDK_VERSION = "2.0.0";
+const EventPayload = Schema.Struct({
+	name: Schema.String,
+	data: Schema.Unknown,
+	ts: Schema.optional(Schema.Number),
+	id: Schema.optional(Schema.String),
+	v: Schema.optional(Schema.String)
+});
+const SendEventResponse = Schema.Struct({
+	ids: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
+	status: Schema.optional(Schema.Number)
+});
+var SendEventError = class extends Schema.TaggedError()("SendEventError", {
+	message: Schema.String,
+	events: Schema.Array(Schema.String)
+}) {};
+/**
+* InngestClient service for communicating with Inngest.
+*
+* @since 0.1.0
+* @category context
+*/
+var InngestClient = class extends Context.Tag("effect-inngest/InngestClient")() {};
+const resolveMode = (config) => config.mode ?? "dev";
+const resolveEventBaseUrl = (config, mode) => config.eventBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_EVENT_BASE_URL);
+const resolveApiBaseUrl = (config, mode) => config.apiBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_API_BASE_URL);
+const makeClient = (config, httpClient) => {
+	const mode = resolveMode(config);
+	const eventBaseUrl = resolveEventBaseUrl(config, mode);
+	const apiBaseUrl = resolveApiBaseUrl(config, mode);
+	const sendEvent = (events) => {
+		if (!config.eventKey && mode === "cloud") return new SendEventError({
+			message: "Event key is required to send events in cloud mode",
+			events: events.map((e) => e.name)
+		});
+		const key = config.eventKey ?? "local";
+		const url = new URL(`e/${key}`, eventBaseUrl).toString();
+		const eventNames = events.map((e) => e.name);
+		const now = Date.now();
+		const payloads = events.map((e) => ({
+			name: e.name,
+			data: e.data ?? {},
+			ts: e.ts ?? now,
+			id: e.id,
+			v: e.v
+		}));
+		const request = HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders({
+			"Content-Type": "application/json",
+			[Headers.SDK]: `effect-ts:v${SDK_VERSION}`,
+			...config.env ? { [Headers.Env]: config.env } : {}
+		}));
+		return HttpClientRequest.schemaBodyJson(Schema.Array(EventPayload))(request, payloads).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(SendEventResponse)), Effect.map((response) => ({
+			ids: response.ids,
+			status: response.status
+		})), Effect.scoped, Effect.catchAll((error) => new SendEventError({
+			message: `Failed to send events: ${Predicate.hasProperty(error, "message") ? error.message : "Unknown error"}`,
+			events: eventNames
+		})));
+	};
+	return {
+		[TypeId]: TypeId,
+		config,
+		mode,
+		eventBaseUrl,
+		apiBaseUrl,
+		sendEvent
+	};
+};
+/**
+* Create an InngestClient layer from a config.
+*
+* @since 0.1.0
+* @category layers
+* @example
+* ```ts
+* const ClientLive = InngestClient.layer({
+*   id: "my-app",
+*   eventKey: "my-event-key",
+* })
+* ```
+*/
+const layer = (config) => Layer.effect(InngestClient, Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(config, httpClient)));
+/**
+* Create an InngestClient layer from Effect Config.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerConfig = (config) => Layer.effect(InngestClient, Effect.flatMap(Config.unwrap(config), (resolvedConfig) => Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(resolvedConfig, httpClient))));
+/**
+* Create an InngestClient layer from environment variables.
+*
+* Uses:
+* - INNGEST_APP_ID or "app" as id
+* - INNGEST_EVENT_KEY for event key
+* - INNGEST_SIGNING_KEY for signing key
+*
+* Mode is inferred from environment (INNGEST_DEV, NODE_ENV, etc.)
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerFromEnv = layerConfig(Config.all({
+	id: Config.string("INNGEST_APP_ID").pipe(Config.withDefault("app")),
+	eventKey: Config.string("INNGEST_EVENT_KEY").pipe(Config.option, Config.map(Option.getOrUndefined)),
+	signingKey: Config.string("INNGEST_SIGNING_KEY").pipe(Config.option, Config.map(Option.getOrUndefined)),
+	signingKeyFallback: Config.string("INNGEST_SIGNING_KEY_FALLBACK").pipe(Config.option, Config.map(Option.getOrUndefined))
+}));
+
+//#endregion
+export { Client_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };

package/dist/Events.d.ts

@@ -0,0 +1,110 @@
+import * as Schema from "effect/Schema";
+
+//#region src/Events.d.ts
+declare namespace Events_d_exports {
+  export { FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };
+}
+declare const JsonError_base: Schema.Class<JsonError, {
+  name: typeof Schema.String;
+  message: typeof Schema.String;
+  stack: Schema.optional<typeof Schema.String>;
+  cause: Schema.optional<typeof Schema.Unknown>;
+}, Schema.Struct.Encoded<{
+  name: typeof Schema.String;
+  message: typeof Schema.String;
+  stack: Schema.optional<typeof Schema.String>;
+  cause: Schema.optional<typeof Schema.Unknown>;
+}>, never, {
+  readonly name: string;
+} & {
+  readonly message: string;
+} & {
+  readonly stack?: string | undefined;
+} & {
+  readonly cause?: unknown;
+}, {}, {}>;
+/**
+ * Error structure used in internal Inngest events.
+ * @since 0.1.0
+ */
+declare class JsonError extends JsonError_base {}
+declare const FunctionFailed_base: Schema.TaggedClass<FunctionFailed, "inngest/function.failed", {
+  readonly _tag: Schema.tag<"inngest/function.failed">;
+} & {
+  function_id: typeof Schema.String;
+  run_id: typeof Schema.String;
+  error: typeof JsonError;
+  event: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+/**
+ * Sent when a function fails after exhausting all retries.
+ * Trigger on this to handle failures (e.g., alerting, cleanup).
+ * @since 0.1.0
+ */
+declare class FunctionFailed extends FunctionFailed_base {}
+declare const FunctionFinishedError_base: Schema.TaggedClass<FunctionFinishedError, "inngest/function.finished", {
+  readonly _tag: Schema.tag<"inngest/function.finished">;
+} & {
+  function_id: typeof Schema.String;
+  run_id: typeof Schema.String;
+  correlation_id: Schema.optional<typeof Schema.String>;
+  error: typeof JsonError;
+}>;
+/**
+ * Sent when a function finishes with an error.
+ * @since 0.1.0
+ */
+declare class FunctionFinishedError extends FunctionFinishedError_base {}
+declare const FunctionFinishedSuccess_base: Schema.TaggedClass<FunctionFinishedSuccess, "inngest/function.finished", {
+  readonly _tag: Schema.tag<"inngest/function.finished">;
+} & {
+  function_id: typeof Schema.String;
+  run_id: typeof Schema.String;
+  correlation_id: Schema.optional<typeof Schema.String>;
+  result: typeof Schema.Unknown;
+}>;
+/**
+ * Sent when a function finishes successfully.
+ * @since 0.1.0
+ */
+declare class FunctionFinishedSuccess extends FunctionFinishedSuccess_base {}
+/**
+ * Union of both FunctionFinished variants.
+ * @since 0.1.0
+ */
+declare const FunctionFinished: Schema.Union<[typeof FunctionFinishedError, typeof FunctionFinishedSuccess]>;
+type FunctionFinished = typeof FunctionFinished.Type;
+declare const FunctionCancelled_base: Schema.TaggedClass<FunctionCancelled, "inngest/function.cancelled", {
+  readonly _tag: Schema.tag<"inngest/function.cancelled">;
+} & {
+  function_id: typeof Schema.String;
+  run_id: typeof Schema.String;
+  correlation_id: Schema.optional<typeof Schema.String>;
+}>;
+/**
+ * Sent when a function is cancelled.
+ * @since 0.1.0
+ */
+declare class FunctionCancelled extends FunctionCancelled_base {}
+declare const FunctionInvoked_base: Schema.TaggedClass<FunctionInvoked, "inngest/function.invoked", {
+  readonly _tag: Schema.tag<"inngest/function.invoked">;
+} & {
+  data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+/**
+ * Sent when a function is invoked via step.invoke().
+ * @since 0.1.0
+ */
+declare class FunctionInvoked extends FunctionInvoked_base {}
+declare const ScheduledTimer_base: Schema.TaggedClass<ScheduledTimer, "inngest/scheduled.timer", {
+  readonly _tag: Schema.tag<"inngest/scheduled.timer">;
+} & {
+  cron: typeof Schema.String;
+}>;
+/**
+ * Sent when a cron trigger fires.
+ * @since 0.1.0
+ */
+declare class ScheduledTimer extends ScheduledTimer_base {}
+//#endregion
+export { Events_d_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Events.js

@@ -0,0 +1,93 @@
+import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import * as Schema from "effect/Schema";
+
+//#region src/Events.ts
+/**
+* Internal Inngest events that the platform sends automatically.
+* Use these as triggers to react to function lifecycle events.
+* @since 0.1.0
+*/
+var Events_exports = /* @__PURE__ */ __exportAll({
+	FunctionCancelled: () => FunctionCancelled,
+	FunctionFailed: () => FunctionFailed,
+	FunctionFinished: () => FunctionFinished,
+	FunctionFinishedError: () => FunctionFinishedError,
+	FunctionFinishedSuccess: () => FunctionFinishedSuccess,
+	FunctionInvoked: () => FunctionInvoked,
+	JsonError: () => JsonError,
+	ScheduledTimer: () => ScheduledTimer
+});
+/**
+* Error structure used in internal Inngest events.
+* @since 0.1.0
+*/
+var JsonError = class extends Schema.Class("JsonError")({
+	name: Schema.String,
+	message: Schema.String,
+	stack: Schema.optional(Schema.String),
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+/**
+* Sent when a function fails after exhausting all retries.
+* Trigger on this to handle failures (e.g., alerting, cleanup).
+* @since 0.1.0
+*/
+var FunctionFailed = class extends Schema.TaggedClass()("inngest/function.failed", {
+	function_id: Schema.String,
+	run_id: Schema.String,
+	error: JsonError,
+	event: Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})
+}) {};
+/**
+* Sent when a function finishes with an error.
+* @since 0.1.0
+*/
+var FunctionFinishedError = class extends Schema.TaggedClass()("inngest/function.finished", {
+	function_id: Schema.String,
+	run_id: Schema.String,
+	correlation_id: Schema.optional(Schema.String),
+	error: JsonError
+}) {};
+/**
+* Sent when a function finishes successfully.
+* @since 0.1.0
+*/
+var FunctionFinishedSuccess = class extends Schema.TaggedClass()("inngest/function.finished", {
+	function_id: Schema.String,
+	run_id: Schema.String,
+	correlation_id: Schema.optional(Schema.String),
+	result: Schema.Unknown
+}) {};
+/**
+* Union of both FunctionFinished variants.
+* @since 0.1.0
+*/
+const FunctionFinished = Schema.Union(FunctionFinishedError, FunctionFinishedSuccess);
+/**
+* Sent when a function is cancelled.
+* @since 0.1.0
+*/
+var FunctionCancelled = class extends Schema.TaggedClass()("inngest/function.cancelled", {
+	function_id: Schema.String,
+	run_id: Schema.String,
+	correlation_id: Schema.optional(Schema.String)
+}) {};
+/**
+* Sent when a function is invoked via step.invoke().
+* @since 0.1.0
+*/
+var FunctionInvoked = class extends Schema.TaggedClass()("inngest/function.invoked", { data: Schema.optional(Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+})) }) {};
+/**
+* Sent when a cron trigger fires.
+* @since 0.1.0
+*/
+var ScheduledTimer = class extends Schema.TaggedClass()("inngest/scheduled.timer", { cron: Schema.String }) {};
+
+//#endregion
+export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };