effect-app 4.0.0-beta.230 → 4.0.0-beta.232

package/src/Schema/ext.ts

@@ -56,7 +56,6 @@ const concurrencySetting = Effect.runSync(
   Config
     .literal("unbounded", "SCHEMA_CONCURRENCY")
     .pipe(Config.orElse(() => Config.number("SCHEMA_CONCURRENCY")), Config.option)
-    .asEffect()
 )
 
 export const DefaultParseOptions: SchemaAST.ParseOptions = {
@@ -86,8 +85,8 @@ export const withDefaultParseOptions = <Decode extends DecodeLike>(
 // TODO: v4 migration - Date is no longer by default encoded to string.
 
 const DateString = S.String.annotate({
-  identifier: "Date",
-  description: "a string in ISO 8601 format that will be decoded as a Date",
+  identifier: "DateOrInvalid",
+  description: "an ISO 8601 date string that will be decoded as a Date (may be invalid)",
   format: "date-time"
 })
 
@@ -113,13 +112,13 @@ export interface DateFromString extends S.decodeTo<S.Date, S.String> {}
 export const DateFromString: DateFromString = DateString.pipe(S.decodeTo(S.Date, SchemaTransformation.dateFromString))
 
 /** Like the default Schema `Date` but from String, with default helpers. */
-export const Date = Object.assign(DateFromString, {
+export const Date = extendM(DateFromString, (s) => ({
   /**
    * Construction-only default `new Date()`. Applied only when the field is
    * omitted from `.make(...)` input. NOT applied during decode — cannot be
    * used to JIT-migrate database fields. See file-level note.
    */
-  withConstructorDefault: DateFromString.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
+  withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
   /**
    * Decode-time default `new Date()`. **Discouraged for persisted data:** a
    * missing field may be data corruption, not an old-shape document; silently
@@ -127,17 +126,29 @@ export const Date = Object.assign(DateFromString, {
    * preferably versioned migration over a decode-time fallback. See
    * file-level note.
    */
-  withDecodingDefaultType: DateFromString.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
+  withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
+}))
+
+const DateValidString = S.String.annotate({
+  identifier: "Date",
+  description: "a valid ISO 8601 date string that will be decoded as a Date",
+  format: "date-time"
 })
 
+const DateValidFromString = DateValidString
+  .pipe(
+    S.decodeTo(S.Date, SchemaTransformation.dateFromString)
+  )
+  .check(isDateValid())
+
 /** Like the default Schema `DateValid` but from String, with default helpers. */
-export const DateValid = Object.assign(Date.check(isDateValid()), {
+export const DateValid = extendM(DateValidFromString, (s) => ({
   /**
    * Construction-only default `new Date()`. Applied only when the field is
    * omitted from `.make(...)` input. NOT applied during decode — cannot be
    * used to JIT-migrate database fields. See file-level note.
    */
-  withConstructorDefault: DateFromString.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
+  withConstructorDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => new global.Date()))),
   /**
    * Decode-time default `new Date()`. **Discouraged for persisted data:** a
    * missing field may be data corruption, not an old-shape document; silently
@@ -145,8 +156,8 @@ export const DateValid = Object.assign(Date.check(isDateValid()), {
    * preferably versioned migration over a decode-time fallback. See
    * file-level note.
    */
-  withDecodingDefaultType: DateFromString.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
-})
+  withDecodingDefaultType: s.pipe(S.withDecodingDefaultType(Effect.sync(() => new global.Date())))
+}))
 
 /** Like the default Schema `Boolean` but with default helpers. */
 export const Boolean = Object.assign(S.Boolean, {

package/src/client/apiClientFactory.ts

@@ -65,7 +65,7 @@ export const HttpClientLayer = (config: ApiConfig) =>
             HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
           HttpClient.mapRequestEffect((req) =>
-            Effect.map(RequestName.asEffect(), (ctx) =>
+            Effect.map(RequestName, (ctx) =>
               flow(
                 HttpClientRequest.appendUrlParam("action", ctx.requestName),
                 HttpClientRequest.appendUrl("/" + ctx.moduleName)

package/src/utils/gen.ts

@@ -1,24 +1,24 @@
-import { type Effect, type Yieldable } from "effect/Effect"
+import { type Effect } from "effect/Effect"
 
 export namespace EffectGenUtils {
   export type Success<EG> = EG extends Effect<infer A, infer _E, infer _R> ? A
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer A, infer _2> ? A
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer _R>, infer A, infer _2> ? A
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer _E, infer _R>, infer A, infer _2> ? A
     : never
 
   export type Error<EG> = EG extends Effect<infer _A, infer E, infer _R> ? E
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer E, infer _R>, infer _A, infer _2> ? E
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer E, infer _R>, infer _A, infer _2> ? E
     : never
 
   export type Context<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
-    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer R>, infer _A, infer _2> ? R
+    // generators yield Effect values
+    : EG extends (..._: infer _3) => Generator<Effect<any, infer _E, infer R>, infer _A, infer _2> ? R
     : never
 }

package/test/schema.test.ts

@@ -461,22 +461,22 @@ describe("JSON Schema", () => {
     })
   })
 
-  test("Date has format date-time and description", () => {
+  test("Date has identifier DateOrInvalid and ISO 8601 description", () => {
     const doc = S.toJsonSchemaDocument(S.Date)
     expect(doc).toStrictEqual({
       dialect: "draft-2020-12",
-      schema: { "$ref": "#/$defs/Date" },
+      schema: { "$ref": "#/$defs/DateOrInvalid" },
       definitions: {
-        Date: {
+        DateOrInvalid: {
           type: "string",
-          description: "a string in ISO 8601 format that will be decoded as a Date",
+          description: "an ISO 8601 date string that will be decoded as a Date (may be invalid)",
           format: "date-time"
         }
       }
     })
   })
 
-  test("DateValid has format date-time", () => {
+  test("DateValid has identifier Date and ISO 8601 description", () => {
     const doc = S.toJsonSchemaDocument(S.DateValid)
     expect(doc).toStrictEqual({
       dialect: "draft-2020-12",
@@ -484,7 +484,7 @@ describe("JSON Schema", () => {
       definitions: {
         Date: {
           type: "string",
-          description: "a string in ISO 8601 format that will be decoded as a Date",
+          description: "a valid ISO 8601 date string that will be decoded as a Date",
           format: "date-time"
         }
       }