effect-app 0.152.0

package/_src/ids.ts

@@ -0,0 +1,35 @@
+import { brandedStringId, withDefaults } from "effect-app/schema"
+import type { StringIdBrand } from "effect-app/schema"
+import type { B } from "@effect-app/schema/schema"
+import type { Simplify } from "effect/Types"
+import { extendM } from "./utils.js"
+
+export interface RequestIdBrand extends StringIdBrand {
+  readonly RequestId: unique symbol
+}
+
+/**
+ * @tsplus type RequestId
+ */
+export type RequestId = NonEmptyString255
+// a request id may be made from a span id, which does not comply with StringId schema.
+export const RequestId = extendM(
+  Object
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as Schema<NonEmptyString255, string>),
+  (s) => {
+    const make = StringId.make as () => NonEmptyString255
+    return ({
+      make,
+      withDefault: S.withDefaultConstructor(s, make)
+    })
+  }
+)
+  .pipe(withDefaults)
+
+export interface UserProfileIdBrand extends Simplify<B.Brand<"UserProfileId"> & StringIdBrand> {}
+/**
+ * @tsplus type UserProfileId
+ */
+export type UserProfileId = StringId & UserProfileIdBrand
+export const UserProfileId = brandedStringId<UserProfileIdBrand>()

package/_src/index.ts

@@ -0,0 +1,4 @@
+import "@effect-app/fluent-extensions"
+
+export * from "@effect-app/core"
+export * as S from "effect-app/schema"

package/_src/refinements.ts

@@ -0,0 +1,92 @@
+import type { Clone } from "@fp-ts/optic"
+import { InvalidStateError } from "./client.js"
+import { clone, copy } from "./utils.js"
+
+/**
+ * @tsplus getter function asCollectable
+ */
+export function asCollectable<T, T2 extends T>(refinement: Refinement<T, T2>) {
+  return Option.liftPredicate(refinement)
+}
+
+/**
+ * @tsplus fluent function as
+ */
+export function as<T, T2 extends T>(refinement: Refinement<T, T2>, name: string) {
+  return flow(
+    asCollectable(refinement),
+    (_) => _.encaseInEither(() => new InvalidStateError(`Cannot be ${name}`))
+  )
+}
+
+/**
+ * @tsplus fluent function refinements
+ */
+export function makeAwesome<T, T2 extends T>(refinement: Refinement<T, T2>, name: string) {
+  const as = refinement.as(name)
+  const validate = {
+    is: refinement,
+    collect: refinement.asCollectable,
+    as,
+    lens: Optic.id<T2>()
+  }
+  function validatei(item: T) {
+    return {
+      get collect() {
+        return validate.collect(item)
+      },
+      get as() {
+        return validate.as(item)
+      }
+    }
+  }
+  return {
+    ...validate,
+    $item: validatei
+  }
+}
+
+// The idea is that such refinements are dynamic
+export interface Collect<A, B extends A> {
+  (a: A): Option<B>
+}
+
+/**
+ * @tsplus fluent function as
+ */
+export function asOption<T, T2 extends T>(collect: Collect<T, T2>, name: string) {
+  return flow(collect, (_) => _.encaseInEither(() => new InvalidStateError({ message: `Cannot be ${name}` })))
+}
+
+/**
+ * @tsplus fluent function refinements
+ */
+export function makeAwesomeCollect<T extends Object, T2 extends T>(collect: Collect<T, T2>, name: string) {
+  const as = collect.as(name)
+  function is(item: T): item is T2 {
+    return collect(item).isSome()
+  }
+  const validate = {
+    collect,
+    is,
+    as,
+    lens: Optic.id<T2>(),
+    copy: (item: T2, _copy: Partial<Omit<T2, keyof Clone | keyof Equal>>) => copy(item, _copy),
+    clone: (item: T, cloned: T) => clone(item, cloned)
+  }
+  function validatei(item: T) {
+    return {
+      get collect() {
+        return validate.collect(item)
+      },
+      get as() {
+        return validate.as(item)
+      }
+    }
+  }
+  return {
+    ...validate,
+    $item: validatei
+  }
+}
+export type GetCollectedType<T> = T extends { collect: Collect<any, infer U> } ? U : never

package/_src/schema/_schema.ts.bak

@@ -0,0 +1,208 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+
+import { identity } from "@effect-app/core/Function"
+import type { AnyError, Parser } from "effect-app/schema"
+import {
+  Guard,
+  maxLengthIdentifier,
+  minLengthIdentifier,
+  NonEmptyString255,
+  NonEmptyString2k,
+  nullableIdentifier
+} from "effect-app/schema"
+import * as S from "effect-app/schema"
+import type { Faker } from "@faker-js/faker"
+import { fakerToArb, getFaker } from "../faker.js"
+
+export { matchTag } from "@effect-app/core/utils"
+
+/**
+ * A little helper to allow writing `interface X extends Identity<typeof Y>`
+ * so you don't need an intermediate type for `typeof Y`
+ */
+export type Identity<T> = T
+
+export function fitIntoNonEmptyString255(str: string) {
+  if (Guard.is(NonEmptyString255)(str)) {
+    return str
+  }
+
+  return NonEmptyString255(str.substring(0, 255 - 3) + "...")
+}
+
+export function fitIntoNonEmptyString2k(str: string) {
+  if (Guard.is(NonEmptyString2k)(str)) {
+    return str
+  }
+
+  return NonEmptyString2k(str.substring(0, 2047 - 3) + "...")
+}
+
+export const fakerArb = (
+  gen: (fake: Faker) => () => string
+): (a: any) => S.Arbitrary.Arbitrary<string> => fakerToArb(gen(getFaker()))
+
+export function tryParse<X, A>(self: Parser.Parser<X, AnyError, A>) {
+  return (a: X, env?: Parser.ParserEnv) => {
+    const res = self(a, env).effect
+    if (res._tag === "Left") {
+      return Option.none()
+    }
+    const warn = res.right[1]
+    if (warn._tag === "Some") {
+      return Option.none()
+    }
+    return Option.some(res.right[0])
+  }
+}
+
+export function isSchema(
+  p: Schema<any, any> | S.AnyField
+): p is Schema<any, any> {
+  return !!(p as any)[S.SchemaSym]
+}
+
+export function getMetadataFromSchemaOrProp(p: Schema<any, any> | S.AnyField) {
+  if (isSchema(p)) {
+    return getMetadataFromSchema(p)
+  }
+  return getMetadataFromProp(p)
+}
+
+// 1. get metadata from properties, use it to constrain fields
+// 2. use the metadata for custom validation error messges?
+// 3. or leverage the actual validation errors that come from parsing the fields.
+// function getMetadataFromProp_<Field extends S.AnyField>(p: Field) {
+//   return {
+//     required: p._optional === "required",
+//   }
+// }
+export function getMetadataFromProp<Field extends S.AnyField>(p: Field) {
+  const schemaMetadata = getMetadataFromSchema(p._schema)
+  // const propMetadata = getMetadataFromProp_(p)
+
+  return schemaMetadata
+  // return {
+  //   ...schemaMetadata,
+  //   required: propMetadata.required && schemaMetadata.required,
+  // }
+}
+
+const numberIds = [
+  S.numberIdentifier
+  // S.stringNumberFromStringIdentifier, actually input is string
+]
+const intIds = [
+  S.intIdentifier,
+  S.intFromNumberIdentifier
+]
+const rangeNumberIds = [
+  S.rangeIdentifier,
+  S.minIdentifier,
+  S.maxIdentifier
+]
+
+export function getMetadataFromSchema<Self extends Schema<any, any>>(self: Self) {
+  const nullable = S.findAnnotation(self, nullableIdentifier)
+  const realSelf = nullable?.self ?? self
+  const minLength = S.findAnnotation(realSelf, minLengthIdentifier)
+  const maxLength = S.findAnnotation(realSelf, maxLengthIdentifier)
+
+  const min = S.findAnnotation(realSelf, S.minIdentifier)
+  const max = S.findAnnotation(realSelf, S.maxIdentifier)
+  const range = S.findAnnotation(realSelf, S.rangeIdentifier)
+
+  const isNumber = numberIds.some((_) => S.findAnnotation(realSelf, _))
+  const isInt = intIds.some((_) => S.findAnnotation(realSelf, _))
+  const asMin = min || range
+  const asMax = max || range
+  const typeN = asMin || asMax
+  return {
+    type: typeN ? typeN.type : isInt ? "int" as const : isNumber ? "float" as const : "text" as const,
+    minimum: asMin?.minimum,
+    minimumExclusive: asMin?.minimumExclusive,
+    maximum: asMax?.maximum,
+    maximumExclusive: asMax?.maximumExclusive,
+    minLength: minLength?.minLength,
+    maxLength: maxLength?.maxLength,
+    required: !nullable
+  }
+}
+
+export function getRegisterFromSchemaOrProp(p: Schema<any, any> | S.AnyField) {
+  if (isSchema(p)) {
+    return getRegisterFromSchema(p)
+  }
+  return getRegisterFromProp(p)
+}
+
+// 1. get metadata from properties, use it to constrain fields
+// 2. use the metadata for custom validation error messges?
+// 3. or leverage the actual validation errors that come from parsing the fields.
+
+export function getRegisterFromProp<Field extends S.AnyField>(p: Field) {
+  const schemaMetadata = getRegisterFromSchema(p._schema)
+  // const metadata = getMetadataFromProp_(p)
+
+  return {
+    ...schemaMetadata
+    // optional fields should not translate values to undefined, as empty value is not absence
+    // ...(!metadata.required
+    //   ? {
+    //       transform: {
+    //         output: (value: any) => (value ? value : undefined),
+    //         input: (value: any) => (!value ? "" : value),
+    //       },
+    //     }
+    //   : {}),
+  }
+}
+
+export function getRegisterFromSchema<Self extends Schema<any, any>>(self: Self) {
+  // or take from openapi = number type?
+  const metadata = getMetadataFromSchema(self)
+  const nullable = S.findAnnotation(self, nullableIdentifier)
+
+  const mapType = numberIds.concat(rangeNumberIds).some((x) => S.findAnnotation(nullable?.self ?? self, x))
+    ? ("asNumber" as const)
+    : ("normal" as const)
+  const map = mapValueType(mapType)
+
+  return {
+    ...(!metadata.required
+      ? {
+        transform: {
+          output: (value: any) => map(value === "" ? null : value),
+          // for date fields we should not undo null..
+          // actually for string fields they appropriately convert to empty string probably anyway, so lets remove
+          // input: (value: any) => (value === null || value === undefined ? "" : value),
+          input: identity
+        }
+      }
+      : { transform: { output: map, input: identity } })
+  }
+}
+
+function asNumber(value: any) {
+  return value === null || value === undefined
+    ? value
+    : value === ""
+    ? NaN
+    : typeof value === "string"
+    ? +value.replace(",", ".")
+    : +value
+}
+
+function asDate(value: any) {
+  return value === null || value === undefined ? value : new Date(value)
+}
+
+function mapValueType(type: "asNumber" | "asDate" | "normal") {
+  return type === "asNumber" ? asNumber : type === "asDate" ? asDate : identity
+}
+
+export * from "effect-app/schema"
+export * from "./overrides.js"
+export { array, nonEmptyArray, set } from "./overrides.js"

package/_src/schema/api/date.ts.bak

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+import { pipe } from "@effect-app/core/Function"
+import { arbitrary, date, encoder, leafE, parseDateE, Parser, parser } from "effect-app/schema"
+import * as Th from "@effect-app/schema/custom/These"
+
+import { todayAtUTCNoon } from "../../utils.js"
+
+export { matchTag } from "@effect-app/core/utils"
+
+// workaround for strange date extension issue.
+const subNow = (amount: number): Date => todayAtUTCNoon().subDays(amount)
+const addNow = (amount: number): Date => todayAtUTCNoon().addDays(amount)
+
+const dateParser = Parser.for(date)
+
+function isProbablyADate(u: unknown): u is Date {
+  return (u instanceof Object && "toISOString" in u && "getTime" in u)
+}
+
+/**
+ * As we want to use actual Date Objects in inputs,
+ * and instead of leveraging the parser as a decoder from JSON, we wish to use it as a validator from Inputs.
+ * This won't work with JSON because a Date is represented as an ISO string inside JSON, and when JSON is parsed, it remains a string.
+ */
+export const inputDate = pipe(
+  date,
+  parser((u, env) =>
+    // if it quacks like a ... Date..
+    u instanceof Date || isProbablyADate(u)
+      ? Number.isNaN(u.getTime())
+        ? Th.fail(leafE(parseDateE(u)))
+        : Th.succeed(u)
+      : dateParser(u, env)
+  ),
+  encoder((i): Date => i.toISOString() as unknown as Date /* sue me*/),
+  arbitrary((FC) =>
+    FC.date({
+      min: subNow(350),
+      max: addNow(350)
+    })
+  )
+)
+
+export type inputDate = Date
+export type InputDate = inputDate
+
+export const reasonablePastDate = date.pipe(
+  arbitrary((FC) =>
+    FC.date({
+      min: subNow(350),
+      max: subNow(1)
+    })
+  )
+)
+export type reasonablePastDate = Date
+export type ReasonablePastDate = reasonablePastDate
+
+export const reasonableFutureDate = date.pipe(
+  arbitrary((FC) =>
+    FC.date({
+      min: addNow(350),
+      max: addNow(1)
+    })
+  )
+)
+export type ReasonableFutureDate = Date
+
+export const reasonableDate = date.pipe(
+  arbitrary((FC) =>
+    FC.date({
+      min: subNow(350),
+      max: addNow(350)
+    })
+  )
+)
+export type reasonableDate = Date
+export type ReasonableDate = reasonableDate

package/_src/schema/api.ts.bak

@@ -0,0 +1,20 @@
+import { brand } from "./_schema.js"
+import { PositiveNumber } from "./overrides.js"
+
+// codegen:start {preset: barrel, include: ./api/*.ts}
+export * from "./api/date.js"
+// codegen:end
+
+// TODO: true decimal
+/**
+ * @deprecated - implement true decimal!
+ */
+export const PositiveDecimal = PositiveNumber.pipe(brand<PositiveDecimal>())
+/**
+ * @deprecated - implement true decimal!
+ */
+export type PositiveDecimal = PositiveNumber & DecimalBrand
+
+export interface DecimalBrand {
+  readonly Decimal: unique symbol
+}

package/_src/schema/overrides.ts.bak

@@ -0,0 +1,76 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+
+import { ReadonlySet } from "@effect-app/core/Prelude"
+import { arbitrary, type PositiveBrand, positiveExcludeZero, type PositiveExcludeZeroBrand } from "effect-app/schema"
+import { brand, positive } from "effect-app/schema"
+import { number } from "effect/Equivalence"
+import { Arbitrary } from "fast-check"
+
+export const PositiveNumber = positive("float")(number).pipe(brand<PositiveNumber>())
+export type PositiveNumber = number & PositiveBrand
+
+export const PositiveNumberZeroExclusive = positiveExcludeZero("float")(number).pipe(brand<PositiveNumber>())
+export type PositiveNumberZeroExclusive = number & PositiveExcludeZeroBrand
+
+export interface CentimeterBrand extends PositiveBrand {
+  readonly CentimeterBrand: unique symbol
+}
+
+export type Centimeter = number & CentimeterBrand
+
+export const Centimeter = positive("float")(number).pipe(brand<Centimeter>())
+
+export interface KilogramBrand extends PositiveBrand {
+  readonly KilogramBrand: unique symbol
+}
+
+export type Kilogram = number & KilogramBrand
+
+export const Kilogram = positive("float")(number).pipe(brand<Kilogram>())
+
+// Limit arbitrary collections to generate a max of 6 entries
+// TODO: dictionary, map
+const MAX_LENGTH = 6
+
+export function nonEmptyArray<To, ConstructorInput, From, Api>(
+  self: Schema<unknown, To, ConstructorInput, From, Api>
+) {
+  const arbitrarySelf = Arbitrary.for(self)
+
+  return nonEmptyArrayOriginal(self).pipe(
+    arbitrary(
+      (_) =>
+        _.array(arbitrarySelf(_), {
+          minLength: 1,
+          maxLength: MAX_LENGTH
+        }) as any as Arbitrary.Arbitrary<NonEmptyReadonlyArray<To>>
+    )
+  )
+}
+
+export function array<To, ConstructorInput, From, Api>(
+  self: Schema<unknown, To, ConstructorInput, From, Api>
+) {
+  const arbitrarySelf = Arbitrary.for(self)
+
+  return arrayOriginal(self).pipe(
+    arbitrary(
+      (_) =>
+        _.array(arbitrarySelf(_), {
+          maxLength: MAX_LENGTH
+        }) as any as Arbitrary.Arbitrary<Array<To>>
+    )
+  )
+}
+
+export function set<To, ConstructorInput, From, Api>(
+  self: Schema<unknown, To, ConstructorInput, From, Api>,
+  ord: Order<To>,
+  eq: Equivalence<To>
+) {
+  const arbitrarySelf = Arbitrary.for(self)
+  return setOriginal(self, ord, eq).pipe(
+    arbitrary((_) => _.uniqueArray(arbitrarySelf(_), { maxLength: MAX_LENGTH }).map(ReadonlySet.fromArray(eq)))
+  )
+}