import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
export interface DesktopIpcInvokeEvent {
readonly sender: { readonly id: number };
}
export interface DesktopIpcSyncEvent {
returnValue: unknown;
}
export type DesktopIpcHandleListener = (
event: DesktopIpcInvokeEvent,
raw: unknown,
) => unknown | Promise<unknown>;
export type DesktopIpcSyncListener = (event: DesktopIpcSyncEvent) => void;
export interface DesktopIpcMain {
removeHandler(channel: string): void;
handle(channel: string, listener: DesktopIpcHandleListener): void;
removeAllListeners(channel: string): void;
on(channel: string, listener: DesktopIpcSyncListener): void;
}
export class DesktopIpcRegistrationError extends Schema.TaggedError<DesktopIpcRegistrationError>()(
"DesktopIpcRegistrationError",
{
handlerKind: Schema.Literals(["invoke", "sync"]),
channel: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to register the ${this.handlerKind} IPC handler for ${this.channel}.`;
}
}
export class DesktopIpcUnregistrationError extends Schema.TaggedError<DesktopIpcUnregistrationError>()(
"DesktopIpcUnregistrationError",
{
handlerKind: Schema.Literals(["invoke", "sync"]),
channel: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to unregister the ${this.handlerKind} IPC handler for ${this.channel}.`;
}
}
export const DesktopIpcError = Schema.Union([
DesktopIpcRegistrationError,
DesktopIpcUnregistrationError,
]);
export type DesktopIpcError = typeof DesktopIpcError.Type;
export interface DesktopIpcMethod<E, R> {
readonly channel: string;
readonly handler: (raw: unknown, event?: DesktopIpcInvokeEvent) => Effect.Effect<unknown, E, R>;
}
export interface DesktopSyncIpcMethod<E, R> {
readonly channel: string;
readonly handler: () => Effect.Effect<unknown, E, R>;
}
export class DesktopIpc extends Context.Service<
DesktopIpc,
{
readonly handle: <E, R>(
input: DesktopIpcMethod<E, R>,
) => Effect.Effect<void, DesktopIpcRegistrationError, R | Scope.Scope>;
readonly handleSync: <E, R>(
input: DesktopSyncIpcMethod<E, R>,
) => Effect.Effect<void, DesktopIpcRegistrationError, R | Scope.Scope>;
}
>()("@t3tools/desktop/ipc/DesktopIpc") {}
export const make = (ipcMain: DesktopIpcMain): DesktopIpc["Service"] =>
DesktopIpc.of({
handle: Effect.fn("desktop.ipc.registerInvoke")(function* <E, R>({
channel,
handler,
}: DesktopIpcMethod<E, R>) {
yield* Effect.annotateCurrentSpan({ channel });
const context = yield* Effect.context<R>();
const runPromise = Effect.runPromiseWith(context);
yield* Effect.acquireRelease(
Effect.try({
try: () => {
ipcMain.removeHandler(channel);
ipcMain.handle(channel, (event, raw) =>
runPromise(
Effect.gen(function* () {
yield* Effect.annotateCurrentSpan({ channel });
return yield* handler(raw, event);
}).pipe(Effect.annotateLogs({ channel }), Effect.withSpan("desktop.ipc.invoke")),
),
);
},
catch: (cause) =>
new DesktopIpcRegistrationError({ handlerKind: "invoke", channel, cause }),
}),
() =>
Effect.try({
try: () => ipcMain.removeHandler(channel),
catch: (cause) =>
new DesktopIpcUnregistrationError({ handlerKind: "invoke", channel, cause }),
}).pipe(Effect.orDie),
);
}),
handleSync: Effect.fn("desktop.ipc.registerSync")(function* <E, R>({
channel,
handler,
}: DesktopSyncIpcMethod<E, R>) {
yield* Effect.annotateCurrentSpan({ channel });
const context = yield* Effect.context<R>();
const runSync = Effect.runSyncWith(context);
yield* Effect.acquireRelease(
Effect.try({
try: () => {
ipcMain.removeAllListeners(channel);
ipcMain.on(channel, (event) => {
event.returnValue = runSync(
Effect.gen(function* () {
yield* Effect.annotateCurrentSpan({ channel });
return yield* handler();
}).pipe(
Effect.annotateLogs({ channel }),
Effect.withSpan("desktop.ipc.invokeSync"),
),
);
});
},
catch: (cause) =>
new DesktopIpcRegistrationError({ handlerKind: "sync", channel, cause }),
}),
() =>
Effect.try({
try: () => ipcMain.removeAllListeners(channel),
catch: (cause) =>
new DesktopIpcUnregistrationError({ handlerKind: "sync", channel, cause }),
}).pipe(Effect.orDie),
);
}),
});
export const layer = (ipcMain: DesktopIpcMain) => Layer.succeed(DesktopIpc, make(ipcMain));
export interface DesktopIpcMethodRegistration<
Payload,
EncodedPayload,
Result,
EncodedResult,
E,
R,
PayloadDecodingServices = never,
PayloadEncodingServices = never,
ResultDecodingServices = never,
ResultEncodingServices = never,
> {
readonly channel: string;
readonly payload: Schema.Codec<
Payload,
EncodedPayload,
PayloadDecodingServices,
PayloadEncodingServices
>;
readonly result: Schema.Codec<
Result,
EncodedResult,
ResultDecodingServices,
ResultEncodingServices
>;
readonly handler: (input: Payload, event?: DesktopIpcInvokeEvent) => Effect.Effect<Result, E, R>;
}
export const makeIpcMethod = <
Payload,
EncodedPayload,
Result,
EncodedResult,
E,
R,
PayloadDecodingServices = never,
PayloadEncodingServices = never,
ResultDecodingServices = never,
ResultEncodingServices = never,
>(
method: DesktopIpcMethodRegistration<
Payload,
EncodedPayload,
Result,
EncodedResult,
E,
R,
PayloadDecodingServices,
PayloadEncodingServices,
ResultDecodingServices,
ResultEncodingServices
>,
): DesktopIpcMethod<
E | Schema.SchemaError,
R | PayloadDecodingServices | ResultEncodingServices
> => {
const decode = Schema.decodeUnknownEffect(method.payload);
const encode = Schema.encodeUnknownEffect(method.result);
return {
channel: method.channel,
handler: (raw, event) =>
decode(raw).pipe(
Effect.flatMap((input) => method.handler(input, event)),
Effect.flatMap(encode),
Effect.withSpan("desktop.ipc.method", { attributes: { channel: method.channel } }),
),
};
};
export interface DesktopSyncIpcMethodRegistration<
Result,
EncodedResult,
E,
R,
ResultDecodingServices = never,
ResultEncodingServices = never,
> {
readonly channel: string;
readonly result: Schema.Codec<
Result,
EncodedResult,
ResultDecodingServices,
ResultEncodingServices
>;
readonly handler: () => Effect.Effect<Result, E, R>;
}
export const makeSyncIpcMethod = <
Result,
EncodedResult,
E,
R,
ResultDecodingServices = never,
ResultEncodingServices = never,
>(
method: DesktopSyncIpcMethodRegistration<
Result,
EncodedResult,
E,
R,
ResultDecodingServices,
ResultEncodingServices
>,
): DesktopSyncIpcMethod<E | Schema.SchemaError, R | ResultEncodingServices> => {
const encode = Schema.encodeUnknownEffect(method.result);
return {
channel: method.channel,
handler: () =>
method
.handler()
.pipe(
Effect.flatMap(encode),
Effect.withSpan("desktop.ipc.method", { attributes: { channel: method.channel } }),
),
};
};