effect-app 1.32.0 → 2.0.1

package/src/Schema/FastCheck.ts

@@ -0,0 +1,23 @@
+import type * as fc from "fast-check"
+
+export type { Arbitrary } from "fast-check"
+type FC = typeof fc
+
+export type { FC }
+
+export const ALPHABET = "abcdefghijklmnopqrstuvwxyz"
+export const ALPHABET_UC = ALPHABET.toUpperCase()
+
+// uppercase A-Z
+const UC_char = (fc: Pick<FC, "integer">) => fc.integer({ min: 0x41, max: 0x5a }).map(String.fromCharCode)
+export const UC_alphabet = (min: number, max: number) => (fc: FC) =>
+  fc.array(UC_char(fc), { minLength: min, maxLength: max }).map((arr) => arr.join(""))
+// lowercase A-Z
+const LC_char = (fc: Pick<FC, "integer">) => fc.integer({ min: 0x61, max: 0x7a }).map(String.fromCharCode)
+export const LC_alphabet = (min: number, max: number) => (fc: Pick<FC, "array" | "integer">) =>
+  fc.array(LC_char(fc), { minLength: min, maxLength: max }).map((arr) => arr.join(""))
+
+// numbers 0-9
+const N_char = (fc: Pick<FC, "integer">) => fc.integer({ min: 0x30, max: 0x39 }).map(String.fromCharCode)
+export const Numbers = (min: number, max: number) => (fc: Pick<FC, "array" | "integer">) =>
+  fc.array(N_char(fc), { minLength: min, maxLength: max }).map((arr) => arr.join(""))

package/src/Schema/Methods.ts

@@ -0,0 +1,8 @@
+export type ReadMethods = "GET"
+export type WriteMethods = "POST" | "PUT" | "PATCH" | "DELETE"
+
+export type Rest = ReadMethods | WriteMethods
+
+export type System = "OPTIONS" | "HEAD" | "TRACE"
+
+export type All = Rest | System

package/src/Schema/brand.ts

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import type { Option } from "effect"
+import * as B from "effect/Brand"
+import type * as Brand from "effect/Brand"
+import type * as Either from "effect/Either"
+import * as S from "effect/Schema"
+
+export interface Constructor<in out A extends B.Brand<any>> {
+  readonly [B.RefinedConstructorsTypeId]: B.RefinedConstructorsTypeId
+  /**
+   * Constructs a branded type from a value of type `A`, throwing an error if
+   * the provided `A` is not valid.
+   */
+  (args: Unbranded<A>): A
+  /**
+   * Constructs a branded type from a value of type `A`, returning `Some<A>`
+   * if the provided `A` is valid, `None` otherwise.
+   */
+  option(args: Unbranded<A>): Option.Option<A>
+  /**
+   * Constructs a branded type from a value of type `A`, returning `Right<A>`
+   * if the provided `A` is valid, `Left<BrandError>` otherwise.
+   */
+  either(args: Unbranded<A>): Either.Either<A, Brand.Brand.BrandErrors>
+  /**
+   * Attempts to refine the provided value of type `A`, returning `true` if
+   * the provided `A` is valid, `false` otherwise.
+   */
+  is(a: Unbranded<A>): a is Unbranded<A> & A
+}
+
+export const fromBrand = <C extends Brand.Brand<string | symbol>>(
+  constructor: Constructor<C>,
+  options?: S.Annotations.Filter<Unbranded<C>>
+) =>
+<R, I, A extends Unbranded<C>>(self: S.Schema<A, I, R>): S.Schema<A & C, I, R> => {
+  return S.fromBrand(constructor as any, options as any)(self as any) as any
+}
+
+export type Brands<P> = P extends B.Brand<any> ? { readonly [B.BrandTypeId]: P[B.BrandTypeId] }
+  : never
+
+export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P
+
+export const nominal: <A extends B.Brand<any>>() => Constructor<A> = <
+  A extends B.Brand<any>
+>(): Constructor<
+  A
+> => B.nominal<A>() as any

package/src/Schema/email.ts

@@ -0,0 +1,22 @@
+import type { Refinement } from "effect-app/Function"
+import { isValidEmail } from "effect-app/validation"
+import * as S from "effect/Schema"
+import type { Simplify } from "effect/Types"
+import type { B } from "./schema.js"
+import type { NonEmptyStringBrand } from "./strings.js"
+
+export interface EmailBrand extends Simplify<NonEmptyStringBrand & B.Brand<"Email">> {}
+
+export type Email = string & EmailBrand
+
+export const Email = S
+  .String
+  .pipe(
+    S.filter(isValidEmail as Refinement<string, Email>, {
+      identifier: "Email",
+      title: "Email",
+      description: "an email according to RFC 5322",
+      jsonSchema: { format: "email" },
+      arbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)
+    })
+  )

package/src/Schema/ext.ts

@@ -0,0 +1,273 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import { Effect, pipe } from "effect"
+import type { ParseResult, SchemaAST } from "effect"
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import type { Schema } from "effect/Schema"
+import * as S from "effect/Schema"
+import { extendM, typedKeysOf } from "../utils.js"
+
+export const withDefaultConstructor: <A, I, R>(
+  makeDefault: () => NoInfer<A>
+) => (self: Schema<A, I, R>) => S.PropertySignature<":", A, never, ":", I, true, R> = (makeDefault) => (self) =>
+  S.propertySignature(self).pipe(S.withConstructorDefault(makeDefault))
+
+export const Date = Object.assign(S.Date, {
+  withDefault: S.Date.pipe(withDefaultConstructor(() => new global.Date()))
+})
+export const Boolean = Object.assign(S.Boolean, {
+  withDefault: S.Boolean.pipe(withDefaultConstructor(() => false))
+})
+export const Number = Object.assign(S.Number, { withDefault: S.Number.pipe(withDefaultConstructor(() => 0)) })
+
+/**
+ * Like the default Schema `Struct` but with batching enabled by default
+ */
+export function Struct<Fields extends S.Struct.Fields, const Records extends S.IndexSignature.NonEmptyRecords>(
+  fields: Fields,
+  ...records: Records
+): S.TypeLiteral<Fields, Records>
+export function Struct<Fields extends S.Struct.Fields>(fields: Fields): S.Struct<Fields>
+export function Struct<Fields extends S.Struct.Fields, const Records extends S.IndexSignature.Records>(
+  fields: Fields,
+  ...records: Records
+): S.TypeLiteral<Fields, Records> {
+  return S.Struct(fields, ...records as any).pipe(S.annotations({ batching: true }))
+}
+
+export declare namespace Struct {
+  export type Fields = S.Struct.Fields
+  export type Type<F extends Fields> = S.Struct.Type<F>
+  export type Encoded<F extends Fields> = S.Struct.Encoded<F>
+  export type Context<F extends Fields> = Schema.Context<F[keyof F]>
+}
+
+/**
+ * Like the default Schema `tuple` but with batching enabled by default
+ */
+export function Tuple<
+  const Elements extends S.TupleType.Elements,
+  Rest extends NonEmptyReadonlyArray<Schema.Any>
+>(elements: Elements, ...rest: Rest): S.TupleType<Elements, Rest>
+export function Tuple<Elements extends S.TupleType.Elements>(...elements: Elements): S.Tuple<Elements>
+export function Tuple(...args: ReadonlyArray<any>): any {
+  return S.Tuple(...args).pipe(S.annotations({ batching: true }))
+}
+
+/**
+ * Like the default Schema `NonEmptyArray` but with batching enabled by default
+ */
+export function NonEmptyArray<Value extends Schema.Any>(value: Value): S.NonEmptyArray<Value> {
+  return pipe(
+    S.NonEmptyArray(value),
+    S.annotations({ batching: true })
+  )
+}
+
+/**
+ * Like the default Schema `Array` but with `withDefault` and batching enabled by default
+ */
+export function Array<Value extends Schema.Any>(value: Value) {
+  return pipe(
+    S.Array(value),
+    S.annotations({ batching: true }),
+    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => [])) })
+  )
+}
+
+/**
+ * Like the default Schema `ReadonlySet` but with `withDefault` and batching enabled by default
+ */
+export const ReadonlySet = <Value extends Schema.Any>(value: Value) =>
+  pipe(
+    S.ReadonlySet(value),
+    S.annotations({ batching: true }),
+    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Set<S.Schema.Type<Value>>())) })
+  )
+
+/**
+ * Like the default Schema `ReadonlyMap` but with `withDefault` and batching enabled by default
+ */
+export const ReadonlyMap = <K extends Schema.Any, V extends Schema.Any>(pair: {
+  readonly key: K
+  readonly value: V
+}) =>
+  pipe(
+    S.ReadonlyMap(pair),
+    S.annotations({ batching: true }),
+    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Map())) })
+  )
+
+/**
+ * Like the default Schema `NullOr` but with `withDefault`
+ */
+export const NullOr = <S extends Schema.Any>(self: S) =>
+  pipe(
+    S.NullOr(self),
+    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => null)) })
+  )
+
+export const defaultDate = <I, R>(s: Schema<Date, I, R>) => s.pipe(withDefaultConstructor(() => new global.Date()))
+
+export const defaultBool = <I, R>(s: Schema<boolean, I, R>) => s.pipe(withDefaultConstructor(() => false))
+
+export const defaultNullable = <A, I, R>(
+  s: Schema<A | null, I, R>
+) => s.pipe(withDefaultConstructor(() => null))
+
+export const defaultArray = <A, I, R>(s: Schema<ReadonlyArray<A>, I, R>) => s.pipe(withDefaultConstructor(() => []))
+
+export const defaultMap = <A, A2, I, R>(s: Schema<ReadonlyMap<A, A2>, I, R>) =>
+  s.pipe(withDefaultConstructor(() => new Map()))
+
+export const defaultSet = <A, I, R>(s: Schema<ReadonlySet<A>, I, R>) =>
+  s.pipe(withDefaultConstructor(() => new Set<A>()))
+
+/**
+ * @tsplus getter effect/schema/Schema withDefaultMake
+ */
+export const withDefaultMake = <Self extends S.Schema<any, any, never>>(s: Self) => {
+  const a = Object.assign(S.decodeSync(s) as WithDefaults<Self>, s)
+  Object.setPrototypeOf(a, s)
+  return a
+
+  // return s as Self & WithDefaults<Self>
+}
+
+export type WithDefaults<Self extends S.Schema<any, any, never>> = (
+  i: S.Schema.Encoded<Self>,
+  options?: SchemaAST.ParseOptions
+) => S.Schema.Type<Self>
+
+// type GetKeys<U> = U extends Record<infer K, any> ? K : never
+// type UnionToIntersection2<U extends object> = {
+//   readonly [K in GetKeys<U>]: U extends Record<K, infer T> ? T : never
+// }
+
+// export type Test<P extends B.Brand<any>> = {
+//   [K in keyof P[B.BrandTypeId]]: K extends string | symbol ? {
+//       readonly [k in K]: k
+//     }
+//     : never
+// }[keyof P[B.BrandTypeId]]
+// export type UnionToIntersection3<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I
+//   : never
+
+export const inputDate = extendM(
+  S.Union(S.ValidDateFromSelf, S.Date),
+  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => new globalThis.Date())) })
+)
+
+export interface UnionBrand {}
+
+const makeOpt = (self: S.PropertySignature.Any, exact?: boolean) => {
+  const ast = self.ast
+  switch (ast._tag) {
+    case "PropertySignatureDeclaration": {
+      return S.makePropertySignature(
+        new S.PropertySignatureDeclaration(
+          exact ? ast.type : S.UndefinedOr(S.make(ast.type)).ast,
+          true,
+          ast.isReadonly,
+          ast.annotations,
+          ast.defaultValue
+        )
+      )
+    }
+    case "PropertySignatureTransformation": {
+      return S.makePropertySignature(
+        new S.PropertySignatureTransformation(
+          new S.FromPropertySignature(
+            exact ? ast.from.type : S.UndefinedOr(S.make(ast.from.type)).ast,
+            true,
+            ast.from.isReadonly,
+            ast.from.annotations
+          ),
+          new S.ToPropertySignature(
+            exact ? ast.to.type : S.UndefinedOr(S.make(ast.to.type)).ast,
+            true,
+            ast.to.isReadonly,
+            ast.to.annotations,
+            ast.to.defaultValue
+          ),
+          ast.decode,
+          ast.encode
+        )
+      )
+    }
+  }
+}
+
+export function makeOptional<NER extends S.Struct.Fields | S.PropertySignature.Any>(
+  t: NER // TODO: enforce non empty
+): {
+  [K in keyof NER]: S.PropertySignature<
+    "?:",
+    Schema.Type<NER[K]> | undefined,
+    never,
+    "?:",
+    Schema.Encoded<NER[K]> | undefined,
+    NER[K] extends S.PropertySignature<any, any, any, any, any, infer Z, any> ? Z : false,
+    Schema.Context<NER[K]>
+  >
+} {
+  return typedKeysOf(t).reduce((prev, cur) => {
+    if (S.isSchema(t[cur])) {
+      prev[cur] = S.optional(t[cur] as any)
+    } else {
+      prev[cur] = makeOpt(t[cur] as any)
+    }
+    return prev
+  }, {} as any)
+}
+
+export function makeExactOptional<NER extends S.Struct.Fields>(
+  t: NER // TODO: enforce non empty
+): {
+  [K in keyof NER]: S.PropertySignature<
+    "?:",
+    Schema.Type<NER[K]>,
+    never,
+    "?:",
+    Schema.Encoded<NER[K]>,
+    NER[K] extends S.PropertySignature<any, any, any, any, any, infer Z, any> ? Z : false,
+    Schema.Context<NER[K]>
+  >
+} {
+  return typedKeysOf(t).reduce((prev, cur) => {
+    if (S.isSchema(t[cur])) {
+      prev[cur] = S.optionalWith(t[cur] as any, { exact: true })
+    } else {
+      prev[cur] = makeOpt(t[cur] as any)
+    }
+    return prev
+  }, {} as any)
+}
+
+/** A version of transform which is only a one way mapping of From->To */
+export const transformTo = <To extends Schema.Any, From extends Schema.Any>(
+  from: From,
+  to: To,
+  decode: (
+    fromA: Schema.Type<From>,
+    options: SchemaAST.ParseOptions,
+    ast: SchemaAST.Transformation,
+    fromI: Schema.Encoded<From>
+  ) => Schema.Encoded<To>
+) =>
+  S.transformOrFail<To, From, never, never>(
+    from,
+    to,
+    { decode: (...args) => Effect.sync(() => decode(...args)), encode: () => Effect.die("one way schema") }
+  )
+
+/** A version of transformOrFail which is only a one way mapping of From->To */
+export const transformToOrFail = <To extends Schema.Any, From extends Schema.Any, RD>(
+  from: From,
+  to: To,
+  decode: (
+    fromA: Schema.Type<From>,
+    options: SchemaAST.ParseOptions,
+    ast: SchemaAST.Transformation
+  ) => Effect.Effect<Schema.Encoded<To>, ParseResult.ParseIssue, RD>
+) => S.transformOrFail<To, From, RD, never>(from, to, { decode, encode: () => Effect.die("one way schema") })

package/src/Schema/moreStrings.ts

@@ -0,0 +1,260 @@
+import { pipe } from "effect"
+import type { Refinement } from "effect-app/Function"
+import { extendM } from "effect-app/utils"
+import type { LazyArbitrary } from "effect/Arbitrary"
+import * as S from "effect/Schema"
+import type { Simplify } from "effect/Types"
+import { customRandom, nanoid, urlAlphabet } from "nanoid"
+import validator from "validator"
+import { fromBrand, nominal } from "./brand.js"
+import type { WithDefaults } from "./ext.js"
+import { withDefaultConstructor, withDefaultMake } from "./ext.js"
+import { type B } from "./schema.js"
+import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.js"
+
+const nonEmptyString = S.String.pipe(S.nonEmptyString())
+
+/**
+ * A string that is at least 1 character long and a maximum of 50.
+ */
+export interface NonEmptyString50Brand extends Simplify<B.Brand<"NonEmptyString50"> & NonEmptyString64Brand> {}
+
+/**
+ * A string that is at least 1 character long and a maximum of 50.
+ */
+export type NonEmptyString50 = string & NonEmptyString50Brand
+
+/**
+ * A string that is at least 1 character long and a maximum of 50.
+ */
+export const NonEmptyString50 = nonEmptyString.pipe(
+  S.maxLength(50),
+  fromBrand(nominal<NonEmptyString50>(), {
+    identifier: "NonEmptyString50",
+    title: "NonEmptyString50",
+    jsonSchema: {}
+  }),
+  withDefaultMake
+)
+
+/**
+ * A string that is at least 1 character long and a maximum of 64.
+ */
+export interface NonEmptyString64Brand extends Simplify<B.Brand<"NonEmptyString64"> & NonEmptyString80Brand> {}
+
+/**
+ * A string that is at least 1 character long and a maximum of 64.
+ */
+export type NonEmptyString64 = string & NonEmptyString64Brand
+
+/**
+ * A string that is at least 1 character long and a maximum of 64.
+ */
+export const NonEmptyString64 = nonEmptyString.pipe(
+  S.maxLength(64),
+  fromBrand(nominal<NonEmptyString64>(), {
+    identifier: "NonEmptyString64",
+    title: "NonEmptyString64",
+    jsonSchema: {}
+  }),
+  withDefaultMake
+)
+
+/**
+ * A string that is at least 1 character long and a maximum of 80.
+ */
+export interface NonEmptyString80Brand extends Simplify<B.Brand<"NonEmptyString80"> & NonEmptyString100Brand> {}
+
+/**
+ * A string that is at least 1 character long and a maximum of 80.
+ */
+export type NonEmptyString80 = string & NonEmptyString80Brand
+
+/**
+ * A string that is at least 1 character long and a maximum of 80.
+ */
+
+export const NonEmptyString80 = nonEmptyString.pipe(
+  S.maxLength(80),
+  fromBrand(nominal<NonEmptyString80>(), {
+    identifier: "NonEmptyString80",
+    title: "NonEmptyString80",
+    jsonSchema: {}
+  }),
+  withDefaultMake
+)
+
+/**
+ * A string that is at least 1 character long and a maximum of 100.
+ */
+export interface NonEmptyString100Brand extends Simplify<B.Brand<"NonEmptyString100"> & NonEmptyString255Brand> {}
+
+/**
+ * A string that is at least 1 character long and a maximum of 100.
+ */
+export type NonEmptyString100 = string & NonEmptyString100Brand
+
+/**
+ * A string that is at least 1 character long and a maximum of 100.
+ */
+export const NonEmptyString100 = nonEmptyString.pipe(
+  S.maxLength(100),
+  fromBrand(nominal<NonEmptyString100>(), {
+    identifier: "NonEmptyString100",
+    title: "NonEmptyString100",
+    jsonSchema: {}
+  }),
+  withDefaultMake
+)
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export interface Min3String255Brand extends Simplify<B.Brand<"Min3String255"> & NonEmptyString255Brand> {}
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export type Min3String255 = string & Min3String255Brand
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export const Min3String255 = pipe(
+  S.String,
+  S.minLength(3),
+  S.maxLength(255),
+  fromBrand(nominal<Min3String255>(), { identifier: "Min3String255", title: "Min3String255", jsonSchema: {} }),
+  withDefaultMake
+)
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export interface StringIdBrand extends Simplify<B.Brand<"StringId"> & NonEmptyString50Brand> {}
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export type StringId = string & StringIdBrand
+
+const makeStringId = (): StringId => nanoid() as unknown as StringId
+const minLength = 6
+const maxLength = 50
+const size = 21
+const length = 10 * size
+const StringIdArb = (): LazyArbitrary<string> => (fc) =>
+  fc
+    .uint8Array({ minLength: length, maxLength: length })
+    .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))())
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export const StringId = extendM(
+  pipe(
+    S.String,
+    S.minLength(minLength),
+    S.maxLength(maxLength),
+    fromBrand(nominal<StringId>(), {
+      identifier: "StringId",
+      title: "StringId",
+      arbitrary: StringIdArb,
+      jsonSchema: {}
+    })
+  ),
+  (s) => ({
+    make: makeStringId,
+    withDefault: s.pipe(withDefaultConstructor(makeStringId))
+  })
+)
+  .pipe(withDefaultMake)
+
+// const prefixedStringIdUnsafe = (prefix: string) => StringId(prefix + StringId.make())
+
+// const prefixedStringIdUnsafeThunk = (prefix: string) => () => prefixedStringIdUnsafe(prefix)
+
+export function prefixedStringId<Brand extends StringId>() {
+  return <Prefix extends string, Separator extends string = "-">(
+    prefix: Prefix,
+    name: string,
+    separator?: Separator
+  ) => {
+    type FullPrefix = `${Prefix}${Separator}`
+    const pref = `${prefix}${separator ?? "-"}` as FullPrefix
+    const arb = (): LazyArbitrary<string & Brand> => (fc) =>
+      StringIdArb()(fc).map(
+        (x) => (pref + x.substring(0, 50 - pref.length)) as Brand
+      )
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const s: S.Schema<string & Brand, string> = StringId
+      .pipe(
+        S.filter((x: StringId): x is string & Brand => x.startsWith(pref), {
+          arbitrary: arb,
+          identifier: name,
+          title: name
+        })
+      )
+    const schema = s.pipe(withDefaultMake)
+    const make = () => (pref + StringId.make().substring(0, 50 - pref.length)) as Brand
+
+    return extendM(
+      schema,
+      (ex): PrefixedStringUtils<Brand, Prefix, Separator> => ({
+        make,
+        /**
+         * Automatically adds the prefix.
+         */
+        unsafeFrom: (str: string) => ex(pref + str),
+        /**
+         * Must provide a literal string starting with prefix.
+         */
+        prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => ex(str),
+        prefix,
+        withDefault: schema.pipe(withDefaultConstructor(make))
+      })
+    )
+  }
+}
+
+export const brandedStringId = <
+  Brand extends StringIdBrand
+>() =>
+  withDefaultMake(
+    Object.assign(Object.create(StringId), StringId) as S.Schema<string & Brand, string> & {
+      make: () => string & Brand
+      withDefault: S.PropertySignature<":", string & Brand, never, ":", string, true, never>
+    } & WithDefaults<S.Schema<string & Brand, string>>
+  )
+
+export interface PrefixedStringUtils<
+  Brand extends StringId,
+  Prefix extends string,
+  Separator extends string
+> {
+  readonly make: () => Brand
+  readonly unsafeFrom: (str: string) => Brand
+  prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => Brand
+  readonly prefix: Prefix
+  readonly withDefault: S.PropertySignature<":", Brand, never, ":", string, true, never>
+}
+
+export interface UrlBrand extends Simplify<B.Brand<"Url"> & NonEmptyStringBrand> {}
+
+export type Url = string & UrlBrand
+
+const isUrl: Refinement<string, Url> = (s: string): s is Url => {
+  return validator.default.isURL(s, { require_tld: false })
+}
+
+export const Url = S
+  .String
+  .pipe(
+    S.filter(isUrl, {
+      arbitrary: (): LazyArbitrary<Url> => (fc) => fc.webUrl().map((_) => _ as Url),
+      identifier: "Url",
+      title: "Url",
+      jsonSchema: { format: "uri" }
+    }),
+    withDefaultMake
+  )