@effect-app/infra 0.217.0 → 0.218.0

package/src/api/routing/match.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
 import type { ValidationError } from "@effect-app/infra/errors"
-import type { StructFields } from "effect-app/schema"
+import type { Struct } from "effect-app/schema"
 import { type RouteDescriptorAny } from "./schema/routing.js"
 import type {} from "effect-app/utils"
 import type { Layer, Ref, Scope } from "effect-app"
@@ -17,13 +17,13 @@ export const RouteDescriptors = Context.GenericTag<Ref<RouteDescriptorAny[]>>("@
 export function match<
   R,
   M,
-  PathA extends StructFields,
-  CookieA extends StructFields,
-  QueryA extends StructFields,
-  BodyA extends StructFields,
-  HeaderA extends StructFields,
+  PathA extends Struct.Fields,
+  CookieA extends Struct.Fields,
+  QueryA extends Struct.Fields,
+  BodyA extends Struct.Fields,
+  HeaderA extends Struct.Fields,
   ReqA extends PathA & QueryA & BodyA,
-  ResA extends StructFields,
+  ResA extends Struct.Fields,
   ResE,
   MiddlewareE,
   PPath extends `/${string}`,

package/src/api/routing/schema/jwt.ts

@@ -17,7 +17,7 @@ export const parseJwt = <R, I, A>(
       (s, __, ast) =>
         S.ParseResult.try({
           try: () => jwtDecode(s, options),
-          catch: (e: any) => S.ParseResult.type(ast, s, e?.message)
+          catch: (e: any) => new S.ParseResult.Type(ast, s, e?.message)
         }),
       (_): Effect<string, ParseIssue> => {
         throw new Error("not implemented")

package/src/services/RepositoryBase.ts

@@ -393,12 +393,12 @@ export function makeRepo<
             _.ast._tag === "Union"
               // we need to get the TypeLiteral, incase of class it's behind a transform...
               ? S.union(..._.ast.types.map((_) =>
-                (S.make(_._tag === "Transform" ? _.from : _) as unknown as Schema<T, From>)
+                (S.make(_._tag === "Transformation" ? _.from : _) as unknown as Schema<T, From>)
                   .pipe(S.pick("id"))
               ))
               : _
                   .ast
-                  ._tag === "Transform"
+                  ._tag === "Transformation"
               ? (S
                 .make(
                   _

package/test/dist/query.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,CAAE,SAAQ,MAOrB;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;IACzB,KAAY,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;CAC3C;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,CAAE,SAAQ,MAOrB;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;IACzB,KAAY,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}

package/test/query.test.ts

@@ -16,12 +16,12 @@ export class s extends S.Class<s>()({
   id: S.StringId.withDefault,
   displayName: S.NonEmptyString255,
   n: S.Date.withDefault,
-  union: someUnion.pipe(
-    S.withDefaultConstructor(() => ({ _tag: "string", value: "hi" }) as S.Schema.To<typeof someUnion>)
-  )
+  union: S.propertySignature(someUnion, {
+    default: () => ({ _tag: "string", value: "hi" }) as S.Schema.Type<typeof someUnion>
+  })
 }) {}
 export declare namespace s {
-  export type From = S.Schema.From<typeof s>
+  export type From = S.Schema.Encoded<typeof s>
 }
 
 const MakeSomeService = Effect.succeed({ a: 1 })
@@ -124,8 +124,8 @@ it("collect", () =>
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.from(S.struct(pick(s.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-                  S.to(S.option(S.string)),
+                  S.encodedSchema(S.struct(pick(s.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
                       ? Option.some(`${_.displayName}-${_.n}`)
@@ -147,8 +147,8 @@ it("collect", () =>
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.from(S.struct(pick(s.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-                  S.to(S.option(S.string)),
+                  S.encodedSchema(S.struct(pick(s.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.union._tag === "string"
                       ? Option.some(_.union.value)