Picking literals in Schema about effect HOT 9 CLOSED

import type * as AST from "@effect/schema/AST"
import * as S from "@effect/schema/Schema"

const pickLiterals =
  <A extends AST.LiteralValue, L extends ReadonlyArray<A>>(...literals: L) =>
  <I, R>(_schema: S.Schema<A, I, R>): S.Schema<L[number]> => S.literal(...literals)

const FruitCategory = S.literal("sweet", "citrus", "tropical")
type FruitsCategory = S.Schema.To<typeof FruitCategory>

const FruitStatus = S.literal("fresh", "notFresh")
type FruitsStatus = S.Schema.To<typeof FruitStatus>

const fruit = <Self>() =>
<Category extends FruitsCategory, Status extends FruitsStatus>(
  category: S.Schema<Category>,
  status: S.Schema<Status>
) => S.Class<Self>()({ fruitId: S.UUID, category, status })

export class Fruit extends fruit<Fruit>()(FruitCategory, FruitStatus) {}

export class FreshAndSweetAndCitrusFruit extends fruit<FreshAndSweetAndCitrusFruit>()(
  FruitCategory.pipe(pickLiterals("sweet", "citrus")),
  FruitStatus.pipe(pickLiterals("fresh"))
) {}

// const pickLiterals =
//   <A extends AST.LiteralValue, L extends ReadonlyArray<A>>(...literals: L) =>
//   <I, R>(_schema: S.Schema<A, I, R>): S.Schema<L[number]> => S.literal(...literals)

const pickLiterals = <A extends AST.LiteralValue>() => <L extends ReadonlyArray<A>>(...literals: L) =>
  S.literal(...literals)

const pickCategory = pickLiterals<FruitsCategory>()
const pickStatus = pickLiterals<FruitsStatus>()

export class FreshAndSweetAndCitrusFruit2 extends fruit<FreshAndSweetAndCitrusFruit2>()(
  pickCategory("sweet", "citrus"),
  pickStatus("fresh")
) {}

Schema.literal("a", "b", "c").pipe(Schema.pickLiteral("a", "b"))

Schema.literal("a", "b")

type ABC = "a" | "b" | "c"

type EntityA = {
  abc: ABC
}

type EntityB = {
  ab: "a" | "b"
}

//A Fruit in General
type FruitsCategory = "sweet" | "citrus" | "tropical"; // source of truth 
type FruitsStatus = "fresh" | "notFresh"; // source of truth

type Fruit = {
  category: FruitsCategory;
  status: FruitsStatus;
};

//A Fruit that is Fresh
type FreshFruit = {
  category: FruitsCategory;
  status: FruitsStatus; //I would like to narrow down to "fresh", 
  //so if someone remove "fresh" from FruitsCategory the error will be reflected here
};

//A Fruit that is Fresh and Sweet
type FreshAndSweetFruit = {
  category: FruitsCategory; //I would like to narrow down to "sweet", 
  //so if someone remove "sweet" from FruitsCategory the error will be reflected here
  status: FruitsStatus; //I would like to narrow down to "fresh", 
  //so if someone remove "fresh" from FruitsStatus the error will be reflected here
};

//A Fruit that is Fresh and Sweet but not a SubType of Fruit: 
type FreshAndSweetFruitButNotASubType = {
  category: "sweet";
  status: "fresh";
};

import * as S from "@effect/schema/Schema"

export type FruitsCategory = "sweet" | "citrus" | "tropical" // source of truth
export type FruitsStatus = "fresh" | "notFresh" // source of truth

export type Fruit<Category extends FruitsCategory, Status extends FruitsStatus> = {
  category: Category
  status: Status
}

export type FreshFruit = Fruit<FruitsCategory, "fresh">

export type FreshAndSweetFruit = Fruit<"sweet", "fresh">

export const fruit = <Category extends FruitsCategory, Status extends FruitsStatus>(
  category: S.Schema<Category>,
  status: S.Schema<Status>
) => S.struct({ category, status })

export const freshFruit = fruit(S.literal("sweet", "citrus", "tropical"), S.literal("fresh"))

export const freshAndSweetFruit = fruit(S.literal("sweet"), S.literal("fresh"))

const FruitId = Schema.UUID;
const FruitCategory = Schema.struct({
  sweet: Schema.literal("sweet"),
  citrus: Schema.literal("citrus"),
  tropical: Schema.literal("tropical"),
});
const FruitStatus = Schema.struct({
  fresh: Schema.literal("fresh"),
  notFresh: Schema.literal("notFresh"),
});

class Fruit extends Schema.Class<Fruit>()({
  id: FruitId,
  category: FruitCategory,
  status: FruitStatus,
}) {}

class FreshAndSweetAndCitrusFruit extends Schema.Class<FreshAndSweetAndCitrusFruit>()(
  {
    fruitId: FruitId,
    category: Schema.union(
      FruitCategory.pipe(Schema.pluck("sweet", { transformation: false })),
      FruitCategory.pipe(Schema.pluck("citrus", { transformation: false }))
    ),
    status: FruitStatus.pipe(Schema.pluck("fresh", { transformation: false })),
  }
) {}

const FruitId = Schema.UUID;
const FruitCategory = Schema.literal("sweet", "citrus", "tropical");
const FruitStatus = Schema.literal("fresh", "notFresh");

class Fruit extends Schema.Class<Fruit>()({
  id: FruitId,
  category: FruitCategory,
  status: FruitStatus,
}) {}

class FreshAndSweetAndCitrusFruit extends Schema.Class<FreshAndSweetAndCitrusFruit>()(
  {
    fruitId: FruitId,
    category: FruitCategory.pipe(Schema.pickLiteral("sweet", "citrus")),
    status: FruitStatus.pipe(Schema.pickLiteral("fresh")),
  }
) {}

const pickLiterals =
  <A extends AST.LiteralValue, L extends ReadonlyArray<A>>(...literals: L) =>
  <I, R>(_schema: S.Schema<A, I, R>): S.Schema<L[number]> => S.literal(...literals)