effect-app 4.0.0-beta.255 → 4.0.0-beta.257

package/src/Schema/numbers.ts

@@ -11,21 +11,21 @@
 import { extendM } from "effect-app/utils"
 import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
+import type * as SchemaAST from "effect/SchemaAST"
 import type { Simplify } from "effect/Types"
-import { fromBrand, nominal } from "./brand.js"
-import { withDefaultMake, type WithDefaults } from "./ext.js"
+import { type BrandedSchema, fromBrand, nominal } from "./brand.js"
+import { withDefaultMake } from "./ext.js"
 import { type B } from "./schema.js"
 
-type BrandedNumberSchema<A extends number> = S.Codec<A, number> & WithDefaults<S.Codec<A, number>>
-type BrandedNumberSchemaWithConstructorDefault<A extends number> = BrandedNumberSchema<A> & {
-  readonly withConstructorDefault: S.Codec<A, number>
-}
-
 export interface PositiveIntBrand
   extends Simplify<B.Brand<"PositiveInt"> & NonNegativeIntBrand & PositiveNumberBrand>
 {}
+export type PositiveInt = number & PositiveIntBrand
 /** Positive integer. `.withConstructorDefault` => `1` (construction-only). */
-export interface PositiveIntSchema extends BrandedNumberSchemaWithConstructorDefault<PositiveInt> {}
+export interface PositiveIntSchema extends BrandedSchema<S.Int, PositiveInt> {
+  (i: number, options?: SchemaAST.ParseOptions): PositiveInt
+  readonly withConstructorDefault: S.withConstructorDefault<BrandedSchema<S.Int, PositiveInt>>
+}
 export const PositiveInt: PositiveIntSchema = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThan(0)),
@@ -41,11 +41,14 @@ export const PositiveInt: PositiveIntSchema = extendM(
     withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1))))
   })
 )
-export type PositiveInt = number & PositiveIntBrand
 
 export interface NonNegativeIntBrand extends Simplify<B.Brand<"NonNegativeInt"> & IntBrand & NonNegativeNumberBrand> {}
+export type NonNegativeInt = number & NonNegativeIntBrand
 /** Non-negative integer. `.withConstructorDefault` => `0` (construction-only). */
-export interface NonNegativeIntSchema extends BrandedNumberSchemaWithConstructorDefault<NonNegativeInt> {}
+export interface NonNegativeIntSchema extends BrandedSchema<S.Int, NonNegativeInt> {
+  (i: number, options?: SchemaAST.ParseOptions): NonNegativeInt
+  readonly withConstructorDefault: S.withConstructorDefault<BrandedSchema<S.Int, NonNegativeInt>>
+}
 export const NonNegativeInt: NonNegativeIntSchema = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThanOrEqualTo(0)),
@@ -64,11 +67,14 @@ export const NonNegativeInt: NonNegativeIntSchema = extendM(
     withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0))))
   })
 )
-export type NonNegativeInt = number & NonNegativeIntBrand
 
 export interface IntBrand extends Simplify<B.Brand<"Int">> {}
+export type Int = number & IntBrand
 /** Integer. `.withConstructorDefault` => `0` (construction-only). */
-export interface IntSchema extends BrandedNumberSchemaWithConstructorDefault<Int> {}
+export interface IntSchema extends BrandedSchema<S.Int, Int> {
+  (i: number, options?: SchemaAST.ParseOptions): Int
+  readonly withConstructorDefault: S.withConstructorDefault<BrandedSchema<S.Int, Int>>
+}
 export const Int: IntSchema = extendM(
   S.Int.pipe(fromBrand<Int>(nominal<Int>(), { identifier: "Int", jsonSchema: {} }), withDefaultMake),
   (s) => ({
@@ -80,11 +86,14 @@ export const Int: IntSchema = extendM(
     withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0))))
   })
 )
-export type Int = number & IntBrand
 
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
+export type PositiveNumber = number & PositiveNumberBrand
 /** Positive finite number. `.withConstructorDefault` => `1` (construction-only). */
-export interface PositiveNumberSchema extends BrandedNumberSchemaWithConstructorDefault<PositiveNumber> {}
+export interface PositiveNumberSchema extends BrandedSchema<S.Finite, PositiveNumber> {
+  (i: number, options?: SchemaAST.ParseOptions): PositiveNumber
+  readonly withConstructorDefault: S.withConstructorDefault<BrandedSchema<S.Finite, PositiveNumber>>
+}
 export const PositiveNumber: PositiveNumberSchema = extendM(
   S.Finite.pipe(
     S.check(S.isGreaterThan(0)),
@@ -103,11 +112,14 @@ export const PositiveNumber: PositiveNumberSchema = extendM(
     withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1))))
   })
 )
-export type PositiveNumber = number & PositiveNumberBrand
 
 export interface NonNegativeNumberBrand extends Simplify<B.Brand<"NonNegativeNumber">> {}
+export type NonNegativeNumber = number & NonNegativeNumberBrand
 /** Non-negative finite number. `.withConstructorDefault` => `0` (construction-only). */
-export interface NonNegativeNumberSchema extends BrandedNumberSchemaWithConstructorDefault<NonNegativeNumber> {}
+export interface NonNegativeNumberSchema extends BrandedSchema<S.Finite, NonNegativeNumber> {
+  (i: number, options?: SchemaAST.ParseOptions): NonNegativeNumber
+  readonly withConstructorDefault: S.withConstructorDefault<BrandedSchema<S.Finite, NonNegativeNumber>>
+}
 export const NonNegativeNumber: NonNegativeNumberSchema = extendM(
   S
     .Finite
@@ -128,7 +140,6 @@ export const NonNegativeNumber: NonNegativeNumberSchema = extendM(
     withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0))))
   })
 )
-export type NonNegativeNumber = number & NonNegativeNumberBrand
 
 /** @deprecated Not an actual decimal */
 export const NonNegativeDecimal = NonNegativeNumber

package/src/Schema/strings.ts

@@ -1,14 +1,15 @@
 import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
+import type * as SchemaAST from "effect/SchemaAST"
 import type { Simplify } from "effect/Types"
-import { fromBrand, nominal } from "./brand.js"
-import { withDefaultMake, type WithDefaults } from "./ext.js"
-
-type BrandedStringSchema<A extends string> = S.Codec<A, string> & WithDefaults<S.Codec<A, string>>
+import { type BrandedSchema, fromBrand, nominal } from "./brand.js"
+import { withDefaultMake } from "./ext.js"
 
 export type NonEmptyStringBrand = B.Brand<"NonEmptyString">
 export type NonEmptyString = string & NonEmptyStringBrand
-export interface NonEmptyStringSchema extends BrandedStringSchema<NonEmptyString> {}
+export interface NonEmptyStringSchema extends BrandedSchema<S.NonEmptyString, NonEmptyString> {
+  (i: string, options?: SchemaAST.ParseOptions): NonEmptyString
+}
 export const NonEmptyString: NonEmptyStringSchema = S
   .NonEmptyString
   .pipe(
@@ -21,7 +22,9 @@ export const NonEmptyString: NonEmptyStringSchema = S
 
 export interface NonEmptyString64kBrand extends Simplify<B.Brand<"NonEmptyString64k"> & NonEmptyStringBrand> {}
 export type NonEmptyString64k = string & NonEmptyString64kBrand
-export interface NonEmptyString64kSchema extends BrandedStringSchema<NonEmptyString64k> {}
+export interface NonEmptyString64kSchema extends BrandedSchema<S.NonEmptyString, NonEmptyString64k> {
+  (i: string, options?: SchemaAST.ParseOptions): NonEmptyString64k
+}
 export const NonEmptyString64k: NonEmptyString64kSchema = S
   .NonEmptyString
   .pipe(
@@ -35,7 +38,9 @@ export const NonEmptyString64k: NonEmptyString64kSchema = S
 
 export interface NonEmptyString2kBrand extends Simplify<B.Brand<"NonEmptyString2k"> & NonEmptyString64kBrand> {}
 export type NonEmptyString2k = string & NonEmptyString2kBrand
-export interface NonEmptyString2kSchema extends BrandedStringSchema<NonEmptyString2k> {}
+export interface NonEmptyString2kSchema extends BrandedSchema<S.NonEmptyString, NonEmptyString2k> {
+  (i: string, options?: SchemaAST.ParseOptions): NonEmptyString2k
+}
 export const NonEmptyString2k: NonEmptyString2kSchema = S
   .NonEmptyString
   .pipe(
@@ -49,7 +54,9 @@ export const NonEmptyString2k: NonEmptyString2kSchema = S
 
 export interface NonEmptyString255Brand extends Simplify<B.Brand<"NonEmptyString255"> & NonEmptyString2kBrand> {}
 export type NonEmptyString255 = string & NonEmptyString255Brand
-export interface NonEmptyString255Schema extends BrandedStringSchema<NonEmptyString255> {}
+export interface NonEmptyString255Schema extends BrandedSchema<S.NonEmptyString, NonEmptyString255> {
+  (i: string, options?: SchemaAST.ParseOptions): NonEmptyString255
+}
 export const NonEmptyString255: NonEmptyString255Schema = S
   .NonEmptyString
   .pipe(

package/src/ids.ts

@@ -24,7 +24,12 @@ export const RequestId = extendM(
   Object
     .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as unknown as Codec<NonEmptyString255, string>),
   (s) => {
-    const make = StringId.make as () => NonEmptyString255
+    function make(): NonEmptyString255
+    function make(input: string, options?: S.MakeOptions): NonEmptyString255
+    function make(input?: string, options?: S.MakeOptions): NonEmptyString255 {
+      const id = input === undefined ? StringId.make() : StringId.make(input, options)
+      return id as NonEmptyString255
+    }
     return ({
       make,
       /**