svelte-effect-runtime 1.6.2 → 2.0.0-beta.1

package/.dist/server/types.d.ts

@@ -0,0 +1,271 @@
+import type { create_form_error, RemoteFailure } from "../remote/shared.js";
+import type { RemoteFormInput, RemoteQuery, RemoteQueryOverride } from "@sveltejs/kit";
+import type { EffectRemoteForm as ClientEffectRemoteForm } from "../remote/client.js";
+import type { Effect, Layer, ManagedRuntime, Schema, Stream } from "effect";
+/**
+ * Effect-like values accepted by remote helper wrappers.
+ *
+ * @since 2.0.0
+ */
+export type EffectLike<A = unknown> = Effect.Effect<A, unknown, unknown> | Effect.gen.Return<A, unknown, unknown>;
+/**
+ * Handler shape accepted by query, command, and prerender helpers.
+ *
+ * @since 2.0.0
+ */
+export type RemoteHandler<Input = unknown, A = unknown> = (input: Input) => EffectLike<A>;
+/**
+ * Handler or source shape accepted by live query helpers.
+ *
+ * @since 2.0.0
+ */
+export type RemoteLiveHandler<Input = unknown, A = unknown> = EffectLike<EffectRemoteLiveSource<A>> | EffectRemoteLiveSource<A> | ((input: Input) => EffectLike<EffectRemoteLiveSource<A>> | EffectRemoteLiveSource<A>);
+/**
+ * Handler shape accepted by batch query helpers. The handler receives the
+ * validated inputs collected by SvelteKit and returns an Effect-producing
+ * resolver for each requested input.
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteBatchHandler<Input = unknown, A = unknown> = (inputs: readonly Input[]) => EffectLike<(input: Input, index: number) => A>;
+/**
+ * Handler shape accepted by the form helper.
+ *
+ * @since 2.0.0
+ */
+export type RemoteFormHandler<Input = unknown, A = unknown> = (input: {
+    readonly data: Input;
+    readonly invalid: FormInvalid;
+    readonly issue: unknown;
+}) => EffectLike<A>;
+/**
+ * Proxy callable used to create typed form validation failures.
+ *
+ * @since 2.0.0
+ */
+export type FormInvalid = {
+    readonly [key: string]: FormInvalid;
+} & ((message: string) => Effect.Effect<never, ReturnType<typeof create_form_error>>);
+/**
+ * Options accepted by the prerender helper.
+ *
+ * @since 2.0.0
+ */
+export type PrerenderOptions = {
+    readonly inputs?: unknown;
+    readonly dynamic?: boolean;
+};
+/**
+ * Minimal Standard Schema shape accepted by SvelteKit remote helpers.
+ *
+ * @since 2.0.0
+ */
+export type StandardSchema = {
+    readonly "~standard": {
+        readonly validate: (input: unknown) => unknown;
+    };
+};
+/**
+ * Extracts the input type from an Effect Schema.
+ *
+ * @since 2.0.0
+ */
+export type SchemaInput<S> = S extends Schema.Schema<infer Input> ? Input : unknown;
+/**
+ * Root and server export shape for building the server-side runtime.
+ *
+ * @since 2.0.0
+ */
+export interface ServerRuntimeFactory {
+    make<R = never>(layer?: Layer.Layer<R>): ManagedRuntime.ManagedRuntime<R, never>;
+}
+/**
+ * Root and server export shape for query helpers.
+ *
+ * @since 2.0.0
+ */
+export interface QueryFactory {
+    <A>(validate_or_handler: EffectLike<A> | RemoteHandler<void, A>): EffectRemoteQueryFunction<void, A>;
+    <Input, A>(validate_or_handler: "unchecked", maybe_handler: RemoteHandler<Input, A>): EffectRemoteQueryFunction<Input, A>;
+    <S extends Schema.Schema<unknown>, A>(validate_or_handler: S, maybe_handler: RemoteHandler<SchemaInput<S>, A>): EffectRemoteQueryFunction<SchemaInput<S>, A>;
+    readonly batch: QueryBatchFactory;
+    readonly live: QueryLiveFactory;
+}
+/**
+ * Root and server export shape for batched query helpers.
+ *
+ * @since 2.0.0
+ */
+export interface QueryBatchFactory {
+    <Input, A>(validate_or_handler: "unchecked", maybe_handler: EffectRemoteBatchHandler<Input, A>): EffectRemoteQueryFunction<Input, A>;
+    <S extends Schema.Schema<unknown>, A>(validate_or_handler: S, maybe_handler: EffectRemoteBatchHandler<SchemaInput<S>, A>): EffectRemoteQueryFunction<SchemaInput<S>, A>;
+}
+/**
+ * Root and server export shape for live query helpers.
+ *
+ * @since 2.0.0
+ */
+export interface QueryLiveFactory {
+    <A>(validate_or_handler: RemoteLiveHandler<void, A>): EffectRemoteLiveQueryFunction<void, A>;
+    <Input, A>(validate_or_handler: "unchecked", maybe_handler: RemoteLiveHandler<Input, A>): EffectRemoteLiveQueryFunction<Input, A>;
+    <S extends Schema.Schema<unknown>, A>(validate_or_handler: S, maybe_handler: RemoteLiveHandler<SchemaInput<S>, A>): EffectRemoteLiveQueryFunction<SchemaInput<S>, A>;
+}
+/**
+ * Root and server export shape for command helpers.
+ *
+ * @since 2.0.0
+ */
+export interface CommandFactory {
+    <A>(validate_or_handler: EffectLike<A> | RemoteHandler<void, A>): EffectRemoteCommand<void, A>;
+    <Input, A>(validate_or_handler: "unchecked", maybe_handler: RemoteHandler<Input, A>): EffectRemoteCommand<Input, A>;
+    <S extends Schema.Schema<unknown>, A>(validate_or_handler: S, maybe_handler: RemoteHandler<SchemaInput<S>, A>): EffectRemoteCommand<SchemaInput<S>, A>;
+}
+/**
+ * Root and server export shape for form helpers.
+ *
+ * @since 2.0.0
+ */
+export interface FormFactory {
+    <A>(validate_or_handler: EffectLike<A> | RemoteFormHandler<void, A>): EffectRemoteForm<void, A>;
+    <Input extends RemoteFormInput, A>(validate_or_handler: "unchecked", maybe_handler: RemoteFormHandler<Input, A>): EffectRemoteForm<Input, A>;
+    <S extends Schema.Schema<unknown>, A>(validate_or_handler: S, maybe_handler: RemoteFormHandler<FormSchemaInput<S>, A>): EffectRemoteForm<FormSchemaInput<S>, A>;
+}
+/**
+ * Root and server export shape for prerender helpers.
+ *
+ * @since 2.0.0
+ */
+export interface PrerenderFactory {
+    (validate_or_handler: unknown, maybe_handler_or_options?: RemoteHandler | PrerenderOptions, maybe_options?: PrerenderOptions): unknown;
+}
+/**
+ * Source values accepted by live query helpers.
+ *
+ * @example
+ * ```ts
+ * const source: EffectRemoteLiveSource<number> = Stream.make(1, 2, 3);
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteLiveSource<A> = Stream.Stream<A, unknown, unknown> | AsyncIterable<A> | AsyncIterator<A> | Iterable<A> | Iterator<A>;
+/**
+ * Effect-returning remote function type exposed by query and prerender.
+ *
+ * @example
+ * ```ts
+ * type Post = { id: string };
+ * const posts: Post[] = [];
+ * const getPosts: EffectRemoteFunction<void, Post[]> = () =>
+ *   Effect.succeed(posts);
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteFunction<Input, A> = [Input] extends [void] ? () => Effect.Effect<A, RemoteFailure<unknown>, unknown> : undefined extends Input ? (input?: Input) => Effect.Effect<A, RemoteFailure<unknown>, unknown> : (input: Input) => Effect.Effect<A, RemoteFailure<unknown>, unknown>;
+/**
+ * Effect-returning query resource with SvelteKit cache update methods
+ * preserved.
+ *
+ * @example
+ * ```ts
+ * const posts = GetPosts();
+ * yield* posts.refresh();
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteQuery<A> = Effect.Effect<A, RemoteFailure<unknown>, never> & Pick<RemoteQuery<A>, "set"> & {
+    readonly current: A | undefined;
+    readonly error: unknown;
+    readonly loading: boolean;
+    readonly ready: boolean;
+    readonly refresh: () => Effect.Effect<void, unknown, never>;
+    readonly withOverride: (update: (current: A) => A) => RemoteQueryOverride;
+};
+/**
+ * Effect-returning remote query function with SvelteKit query resource methods
+ * preserved on the returned Effect.
+ *
+ * @example
+ * ```ts
+ * const posts = GetPosts();
+ * yield* posts;
+ * yield* posts.refresh();
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteQueryFunction<Input, A> = [Input] extends [void] ? () => EffectRemoteQuery<A> : undefined extends Input ? (input?: Input) => EffectRemoteQuery<A> : (input: Input) => EffectRemoteQuery<A>;
+/**
+ * Effect-returning live query resource with SvelteKit live stream state and
+ * reconnect controls preserved.
+ *
+ * @example
+ * ```ts
+ * const clock = getClock();
+ * yield* clock.reconnect();
+ *
+ * for await (const value of clock) {
+ *   console.log(value);
+ * }
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteLiveQuery<A> = Effect.Effect<A, RemoteFailure<unknown>, never> & AsyncIterable<A> & {
+    readonly connected: boolean;
+    readonly current: A | undefined;
+    readonly done: boolean;
+    readonly error: unknown;
+    readonly loading: boolean;
+    readonly ready: boolean;
+    readonly reconnect: () => Effect.Effect<void, unknown, never>;
+};
+/**
+ * Effect-returning remote live query function with SvelteKit live stream
+ * properties preserved on the returned Effect.
+ *
+ * @example
+ * ```ts
+ * const clock = getClock();
+ * yield* clock;
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteLiveQueryFunction<Input, A> = [Input] extends [void] ? () => EffectRemoteLiveQuery<A> : undefined extends Input ? (input?: Input) => EffectRemoteLiveQuery<A> : (input: Input) => EffectRemoteLiveQuery<A>;
+/**
+ * Effect-returning command type with SvelteKit's pending counter preserved.
+ *
+ * @example
+ * ```ts
+ * const upvote: EffectRemoteCommand<string, number> = Object.assign(
+ *   (id: string) => Effect.succeed(id.length),
+ *   { pending: 0 },
+ * );
+ * ```
+ *
+ * @since 2.0.0
+ */
+export type EffectRemoteCommand<Input, A> = EffectRemoteFunction<Input, A> & {
+    readonly pending: number;
+};
+/**
+ * Effect-returning form type with SvelteKit form helpers preserved.
+ *
+ * @example
+ * ```ts
+ * const signIn: EffectRemoteForm<{ email: string }, { ok: true }> =
+ *   Form(Schema.Struct({ email: Schema.String }), ({ data }) =>
+ *     Effect.succeed({ ok: data.email.length > 0 })
+ *   );
+ * ```
+ *
+ * @since 2.0.0
+ * @template Input - Data shape submitted by the remote form.
+ * @template A - Successful value produced by the form handler.
+ */
+export type EffectRemoteForm<Input extends RemoteFormInput | void, A> = ClientEffectRemoteForm<Input, A>;
+type FormSchemaInput<S> = SchemaInput<S> extends RemoteFormInput ? SchemaInput<S> : never;
+export {};

package/.dist/server/wrappers.d.ts

@@ -0,0 +1,45 @@
+import type { EffectLike, EffectRemoteLiveSource, RemoteFormHandler, RemoteHandler } from "./types.js";
+type RemoteLiveHandler<Input = unknown, A = unknown> = EffectLike<EffectRemoteLiveSource<A>> | EffectRemoteLiveSource<A> | ((input: Input) => EffectLike<EffectRemoteLiveSource<A>> | EffectRemoteLiveSource<A>);
+/**
+ * Reports whether SER is currently executing user remote handler code.
+ *
+ * @example
+ * ```ts
+ * if (is_running_remote_effect_handler()) {
+ *   return query();
+ * }
+ * ```
+ *
+ * @since 2.0.0
+ * @returns Whether a remote handler wrapper is currently active.
+ * @internal
+ */
+export declare function is_running_remote_effect_handler(): boolean;
+/**
+ * Builds the wrapper passed to native query, command, and prerender helpers.
+ *
+ * @since 2.0.0
+ * @param handler - Effect handler or already-built Effect-like value.
+ * @param helper_name - Remote helper name for error normalization.
+ * @returns Native SvelteKit handler wrapper.
+ */
+export declare function make_remote_wrapper(handler: RemoteHandler | EffectLike, helper_name: string): (input: unknown) => Promise<unknown>;
+/**
+ * Builds the wrapper passed to native live query helpers.
+ *
+ * @since 2.0.0
+ * @param handler - Effect-aware live source handler.
+ * @param helper_name - Remote helper name for error normalization.
+ * @returns Native SvelteKit live query wrapper.
+ */
+export declare function make_remote_live_wrapper<Input, A>(handler: RemoteLiveHandler<Input, A>, helper_name: string): (input: unknown) => Promise<unknown>;
+/**
+ * Builds the wrapper passed to native form helpers.
+ *
+ * @since 2.0.0
+ * @param handler - Effect-aware form handler.
+ * @param helper_name - Remote helper name for error normalization.
+ * @returns Native SvelteKit form handler wrapper.
+ */
+export declare function make_remote_form_wrapper<Input, A>(handler: RemoteFormHandler<Input, A>, helper_name: string): (data: unknown, issue: unknown) => Promise<unknown>;
+export {};

package/.dist/server.d.ts

@@ -0,0 +1,2 @@
+export { Command, Form, get_server_runtime_or_throw, Prerender, Query, RequestEvent, ServerRuntime, } from "./server/index.js";
+export type { EffectLike, EffectRemoteBatchHandler, EffectRemoteCommand, EffectRemoteForm, EffectRemoteFunction, EffectRemoteLiveQuery, EffectRemoteLiveQueryFunction, EffectRemoteLiveSource, EffectRemoteQuery, EffectRemoteQueryFunction, FormInvalid, PrerenderOptions, RemoteFormHandler, RemoteHandler, SchemaInput, StandardSchema, } from "./server/index.js";