@shivaedev/effect-contract 0.4.0 → 0.5.0

package/src/operation.ts

@@ -3,15 +3,15 @@ import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import type { Key } from "./keys.ts";
 import { type MatchingTags, type Reject, type RejectionSpecs, type Rejections, type RejectionUnion, rejectionSet } from "./rejection.ts";
 
-export type PayloadSchema<Payload extends Schema.Top | Schema.Struct.Fields> = Payload extends Schema.Struct.Fields
-	? Schema.Struct<Payload>
-	: Payload;
+export type PayloadSchema<TPayload extends Schema.Top | Schema.Struct.Fields> = TPayload extends Schema.Struct.Fields
+	? Schema.Struct<TPayload>
+	: TPayload;
 
 type NoRejections = Record<never, never>;
 
 export interface OperationShape {
 	readonly error: Schema.Top;
-	readonly kind: "query" | "command";
+	readonly kind: "query" | "command" | "stream";
 	readonly name: string;
 	readonly payload: Schema.Top;
 	readonly Rejection: object;
@@ -25,38 +25,49 @@ export interface QueryShape extends OperationShape {
 	reads: Bivariant<(payload: unknown) => readonly Key[]>;
 }
 
+export interface StreamShape extends OperationShape {
+	readonly kind: "stream";
+	reads: Bivariant<(payload: unknown) => readonly Key[]>;
+}
+
 export interface CommandShape extends OperationShape {
 	invalidates: Bivariant<(payload: unknown, result: unknown) => readonly Key[]>;
 	readonly kind: "command";
 }
 
-interface Operation<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
+interface Operation<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
 	extends OperationShape {
-	readonly error: RejectionUnion<Specs>;
-	readonly name: Name;
-	readonly payload: Payload;
-	readonly Rejection: Rejections<Specs>;
-	readonly reject: Reject<Specs>;
-	readonly rejections: Specs;
-	readonly success: Success;
+	readonly error: RejectionUnion<TSpecs>;
+	readonly name: TName;
+	readonly payload: TPayload;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
+	readonly rejections: TSpecs;
+	readonly success: TSuccess;
 }
 
-export interface Query<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
+export interface Query<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
 	readonly kind: "query";
-	reads: (payload: Payload["Type"]) => readonly Key[];
+	reads: (payload: TPayload["Type"]) => readonly Key[];
 }
 
-export interface Command<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
-	invalidates: (payload: Payload["Type"], result: Success["Type"]) => readonly Key[];
+export interface Streaming<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	readonly kind: "stream";
+	reads: (payload: TPayload["Type"]) => readonly Key[];
+}
+
+export interface Command<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	invalidates: (payload: TPayload["Type"], result: TSuccess["Type"]) => readonly Key[];
 	readonly kind: "command";
 }
 
-interface Declaration<Payload extends Schema.Top | Schema.Struct.Fields, Success extends Schema.Top, Specs extends RejectionSpecs> {
-	readonly payload?: Payload;
-	readonly rejections?: Specs & MatchingTags<Specs>;
-	readonly success?: Success;
+interface Declaration<TPayload extends Schema.Top | Schema.Struct.Fields, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs> {
+	readonly payload?: TPayload;
+	readonly rejections?: TSpecs & MatchingTags<TSpecs>;
+	readonly success?: TSuccess;
 }
 
 interface Loose {
@@ -65,14 +76,14 @@ interface Loose {
 	readonly success?: Schema.Top;
 }
 
-const payloadSchema = (payload: Loose["payload"]): Schema.Top => {
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
 	if (payload === undefined) {
 		return Schema.Void;
 	}
 	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
-};
+}
 
-const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string, declaration: Loose) => {
+function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
 	const { payload, success, rejections = {} } = declaration;
 	return {
 		kind,
@@ -82,37 +93,53 @@ const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string
 		success: success ?? Schema.Void,
 		...rejectionSet(rejections),
 	};
-};
+}
 
 export function query<
-	const Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
 >(
-	name: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly reads: (payload: PayloadSchema<Payload>["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
 	},
-): NoInfer<Query<Name, PayloadSchema<Payload>, Success, Specs>>;
+): NoInfer<Query<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
 export function query(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): QueryShape {
 	return { ...operation("query", name, declaration), reads: declaration.reads };
 }
 
 export function command<
-	const Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
 >(
-	name: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly invalidates: (payload: PayloadSchema<Payload>["Type"], result: Success["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"]) => readonly Key[];
 	},
-): NoInfer<Command<Name, PayloadSchema<Payload>, Success, Specs>>;
+): NoInfer<Command<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
 export function command(
 	name: string,
 	declaration: Loose & { readonly invalidates: (payload: unknown, result: unknown) => readonly Key[] },
 ): CommandShape {
 	return { ...operation("command", name, declaration), invalidates: declaration.invalidates };
 }
+
+export function stream<
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
+>(
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly success: TSuccess;
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
+	},
+): NoInfer<Streaming<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
+export function stream(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): StreamShape {
+	return { ...operation("stream", name, declaration), reads: declaration.reads };
+}

package/src/rejection.ts

@@ -1,10 +1,11 @@
 import { type Cause, Effect, Schema } from "effect";
 
-export type RejectionValue<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.TaggedStruct<Tag, Fields>["Type"] & Cause.YieldableError;
+export type RejectionValue<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.TaggedStruct<TTag, TFields>["Type"] &
+	Cause.YieldableError;
 
-export type RejectionClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<
-	RejectionValue<Tag, Fields>,
-	Schema.TaggedStruct<Tag, Fields>,
+export type RejectionClass<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.Class<
+	RejectionValue<TTag, TFields>,
+	Schema.TaggedStruct<TTag, TFields>,
 	Cause.YieldableError
 >;
 
@@ -14,42 +15,42 @@ export interface RejectionSpecs {
 	readonly [tag: string]: Schema.Struct.Fields | TaggedRejection;
 }
 
-export type Rejections<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs & string]: Specs[Tag] extends TaggedRejection
-		? Specs[Tag]
-		: Specs[Tag] extends Schema.Struct.Fields
-			? RejectionClass<Tag, Specs[Tag]>
+export type Rejections<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]
+		: TSpecs[TTag] extends Schema.Struct.Fields
+			? RejectionClass<TTag, TSpecs[TTag]>
 			: never;
 };
 
-export type RejectedBy<Specs extends RejectionSpecs> = {
-	[Tag in keyof Specs & string]: Rejections<Specs>[Tag]["Type"];
-}[keyof Specs & string];
+export type RejectedBy<TSpecs extends RejectionSpecs> = {
+	[TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag]["Type"];
+}[keyof TSpecs & string];
 
-export type Reject<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs & string]: Rejections<Specs>[Tag] extends new (
-		...args: infer Arguments
-	) => infer Value
-		? (...args: Arguments) => Effect.Effect<never, Value>
+export type Reject<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag] extends new (
+		...args: infer TArguments
+	) => infer TValue
+		? (...args: TArguments) => Effect.Effect<never, TValue>
 		: never;
 };
 
-export type RejectionUnion<Specs extends RejectionSpecs> = [keyof Specs & string] extends [never]
+export type RejectionUnion<TSpecs extends RejectionSpecs> = [keyof TSpecs & string] extends [never]
 	? Schema.Never
-	: Schema.Union<readonly Rejections<Specs>[keyof Specs & string][]>;
+	: Schema.Union<readonly Rejections<TSpecs>[keyof TSpecs & string][]>;
 
-export type MatchingTags<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs]: Specs[Tag] extends TaggedRejection
-		? Specs[Tag]["Type"] extends { readonly _tag: Tag }
-			? Specs[Tag]
-			: `The rejection class under "${Tag & string}" must have that _tag`
-		: Specs[Tag];
+export type MatchingTags<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]["Type"] extends { readonly _tag: TTag }
+			? TSpecs[TTag]
+			: `The rejection class under "${TTag & string}" must have that _tag`
+		: TSpecs[TTag];
 };
 
-export interface RejectionSet<Specs extends RejectionSpecs> {
-	readonly error: RejectionUnion<Specs>;
-	readonly Rejection: Rejections<Specs>;
-	readonly reject: Reject<Specs>;
+export interface RejectionSet<TSpecs extends RejectionSpecs> {
+	readonly error: RejectionUnion<TSpecs>;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
 }
 
 interface LooseRejectionSet {
@@ -58,7 +59,7 @@ interface LooseRejectionSet {
 	readonly reject: { readonly [tag: string]: (...args: readonly unknown[]) => Effect.Effect<never, unknown> };
 }
 
-export function rejectionSet<const Specs extends RejectionSpecs>(specs: Specs): RejectionSet<Specs>;
+export function rejectionSet<const TSpecs extends RejectionSpecs>(specs: TSpecs): RejectionSet<TSpecs>;
 export function rejectionSet(specs: RejectionSpecs): LooseRejectionSet {
 	const classes = Object.entries(specs).map(([tag, spec]): readonly [string, TaggedRejection] => [
 		tag,
@@ -73,16 +74,18 @@ export function rejectionSet(specs: RejectionSpecs): LooseRejectionSet {
 	};
 }
 
-export type FieldRejection<Field extends string> = Readonly<{
-	field: Schema.Literals<readonly Field[]>;
+export type FieldRejection<TField extends string> = Readonly<{
+	field: Schema.Literals<readonly TField[]>;
 	message: Schema.String;
 }>;
 
-export function fieldRejection<const Fields extends Schema.Struct.Fields>(struct: { readonly fields: Fields }): FieldRejection<keyof Fields & string>;
-export function fieldRejection<const Fields extends Schema.Struct.Fields, const Field extends keyof Fields & string>(
-	struct: { readonly fields: Fields },
-	fields: readonly Field[],
-): FieldRejection<Field>;
+export function fieldRejection<const TFields extends Schema.Struct.Fields>(struct: {
+	readonly fields: TFields;
+}): FieldRejection<keyof TFields & string>;
+export function fieldRejection<const TFields extends Schema.Struct.Fields, const TField extends keyof TFields & string>(
+	struct: { readonly fields: TFields },
+	fields: readonly TField[],
+): FieldRejection<TField>;
 export function fieldRejection(struct: { readonly fields: Schema.Struct.Fields }, fields?: readonly string[]): FieldRejection<string> {
 	return { field: Schema.Literals(fields ?? Object.keys(struct.fields)), message: Schema.String };
 }

package/src/resume.ts

@@ -1,4 +1,4 @@
-import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Atom from "effect/reactivity/Atom";
 
 export type ResumeSource = (resume: () => void) => () => void;