`Schema.fromBranded` loses type information about the union brands

[nikelborm]

What version of Effect is running?

4.0.0-rc.117

What steps can reproduce the bug?

All of the annotated code is available in the repo v3-v4-effect-repros:

git clone -b main https://github.com/nikelborm/v3-v4-effect-repros.git
cd v3-v4-effect-repros/effect-v3-behavior/
bun i
# All of the errors are expected
bun tsc
cd ../effect-v4-behavior/
bun i
# 1 expected error is missing, and 1 other unexpected error is present
bun tsc

import { Brand, Schema } from "effect";

type MIDIPortType = "input" | "output";

type Id<TPortType extends MIDIPortType> =
	// for distribution
	TPortType extends MIDIPortType
		? Brand.Branded<string, "MIDIPortId"> & Brand.Brand<TPortType>
		: never;

// | (string & Brand.Brand<"MIDIPortId"> & Brand.Brand<"input">)
// | (string & Brand.Brand<"MIDIPortId"> & Brand.Brand<"output">)
export type InputOrOutputMidiPortId = Id<MIDIPortType>;

// Brand.Constructor<InputOrOutputMidiPortId>
export const InputOrOutputMidiPortId = Brand.check<InputOrOutputMidiPortId>(
	Schema.isTrimmed(),
	Schema.isMinLength(5),
);

// UNEXPECTED: no 'input' | 'output' anywhere:
// Schema.brand<Schema.String, "MIDIPortId">
const InputOrOutputMidiPortIdBrokenSchema = Schema.String.pipe(
	Schema.fromBrand("InputOrOutputMidiPortId", InputOrOutputMidiPortId),
);

What is the expected behavior?

The same behavior that I otherwise need to achieve with this workaround:

const Base = Schema.String.pipe(
	Schema.fromBrand("MIDIPortId", InputOrOutputMidiPortId),
);

// Deliberately not using Schema.toType(Base) to avoid running the checks twice
const BaseType = Schema.brand("MIDIPortId")(Schema.Unknown as unknown as Schema.String)

return Schema.Union([
	BaseType.pipe(Schema.brand("output")),
	BaseType.pipe(Schema.brand("input")),
]).pipe(Schema.encodeTo(Base));

What do you see instead?

Essentially, these 2 produce different types:

Option.getOrThrow(InputOrOutputMidiPortIdBrand.option('12345'))

// loses 'input' | 'output'
Schema.decodeSync(InputOrOutputMidiPortIdSchema)('12325')

index.ts:59:38 - error TS1360: Type 'string & Brand<"MIDIPortId">' does not satisfy the expected type 'string & ((Brand<"MIDIPortId"> & Brand<"input">) | (Brand<"MIDIPortId"> & Brand<"output">))'.
  Type 'string & Brand<"MIDIPortId">' is not assignable to type 'string & Brand<"MIDIPortId"> & Brand<"output">'.
    Type 'string & Brand<"MIDIPortId">' is not assignable to type 'Brand<"output">'.
      Types of property '[TypeId]' are incompatible.
        Property 'output' is missing in type '{ readonly MIDIPortId: "MIDIPortId"; }' but required in type '{ readonly output: "output"; }'.

59 Schema.decodeSync(IdSchema)("12325") satisfies string &
                                        ~~~~~~~~~

Additional information

No response

[gcanti]

At runtime, fromBrand receives the checks, such as isTrimmed and isMinLength, plus the single identifier "InputOrOutputMidiPortId". It receives no information saying that the type has two branches named "input" and "output".

Changing only the return type of fromBrand would make TypeScript display the union, but the schema itself would still contain one string node. If the schema is converted to SchemaRepresentation and rebuilt, the union would be lost because it was never stored in the schema.

The two branches need to be defined explicitly with Schema.Union. I think fromBrand should reject union constructors instead of returning a type it cannot represent.

[nikelborm]

Do you think it would be a good idea to add Brand.compose (&) and Brand.union (|) combinators so that it's possible to properly reconstruct the schema tree with all the necessary nodes ?

type MIDIPortType = "input" | "output";
export type MIDIPortId = Brand.Branded<string, "MIDIPortId">;

// Brand.Constructor<MIDIPortId>
const MIDIPortId = Brand.check<MIDIPortId>(
	Schema.isTrimmed(),
	Schema.isMinLength(5),
);

const InputPortId = Brand.compose([MIDIPortId, Brand.nominal('input')])
const OutputPortId = Brand.compose([MIDIPortId, Brand.nominal('output')])

const InputOrOutputMidiPortId = Brand.union([InputPortId, OutputPortId])

// 'InputOrOutputMidiPortId' is a plain string; it doesn't become part of the type
Schema.fromBrand('InputOrOutputMidiPortId', InputOrOutputMidiPortId)

[nikelborm]

And generally, shouldn't the identifiers be part of the brand itself at runtime as well, so that schemas can reuse them ?

[nikelborm]

The workaround with schema composition I mentioned in this issue initially has some downsides, in particular the same checks are running repeatedly:

const Base = Schema.String.pipe(
	Schema.fromBrand("MIDIPortId", InputOrOutputMidiPortId),
);

// Deliberately not using Schema.toType(Base) to avoid running the checks twice
const BaseType = Schema.Unknown as unknown as Schema.branded<Schema.String, "MIDIPortId">

return Schema.Union([
	BaseType.pipe(Schema.brand("output")),
	BaseType.pipe(Schema.brand("input")),
]).pipe(Schema.encodeTo(Base));

When decoding from string & "MIDIPortId" to attach an additional brand, it repeats the same is string, is trimmed, is min length checks when BaseType = Base or BaseType = Schema.toType(Base).

How do I easily disable them without the need to lie to schemas like below?

const BaseType = Schema.Unknown as unknown as Schema.branded<Schema.String, "MIDIPortId">

This is a hack and a footgun. Without it, many checks will run repeatedly, doing unnecessary work. And if I don't do this hack, the type collapses and becomes even worse. This is what I get when the BaseType is Schema.Unknown without type override:

// const asdc: Brand.Brand<"input"> | Brand.Brand<"output">
const asdc = Schema.decodeSync(InputOrOutputMidiPortIdWorkaroundSchema)("12325")

I intuitively expected it to be intersected with string & Brand.Brand<"MIDIPortId"> since it's a passthrough transformation. string & unknown produces string

And I need the hack even for a case like this:

const Base = Schema.String.pipe(
	Schema.fromBrand("MIDIPortId", InputOrOutputMidiPortId),
);

Schema.Union([
	Base.pipe(Schema.brand("output")),
	Base.pipe(Schema.brand("input")),
])

Why? Because it still has a chance to run all the checks twice, but on failure instead

[nikelborm]

The issue in the previous comment probably arises because there isn't a standalone Schema.Brand('') which is a node itself; instead, Schema.brand is a function that must take at least something.

With such a schema maker, it would probably be possible to do something like this:

const Base = Schema.String.pipe(
	Schema.fromBrand("MIDIPortId", InputOrOutputMidiPortId),
);

return Schema.Union([
	Schema.Brand("output"),
	Schema.Brand("input"),
]).pipe(Schema.encodeTo(Base));