effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/internal/schema/fromRepresentation.ts

@@ -2,9 +2,11 @@ import * as Arr from "../../Array.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
 import type * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalRecord from "../record.ts"
+import * as InternalToCodec from "./toCodec.ts"
 
 type Path = ReadonlyArray<string | number>
 
@@ -43,7 +45,7 @@ function makeReviverMap(
     }
     out.set(reviver.id, {
       ...reviver,
-      payloadSchema: Schema.toCodecJson(reviver.payloadSchema)
+      payloadSchema: InternalToCodec.toCodecJson(reviver.payloadSchema)
     })
   }
 
@@ -102,7 +104,7 @@ function revivePersisted(
     reviver: SchemaRepresentation.AnyReviver,
     path: Path
   ): any {
-    const decoded = Schema.decodeUnknownResult(reviver.payloadSchema)(representation.payload)
+    const decoded = SchemaParser.decodeUnknownResult(reviver.payloadSchema)(representation.payload)
     if (Result.isFailure(decoded)) {
       throw errorWithPath(`Invalid representation payload for ${representation.id}`, path)
     }
@@ -314,7 +316,7 @@ function revivePersisted(
       }
       case "Union": {
         const members = representation.types.map((member, index) => recur(member, [...path, "types", index]))
-        return finishStructural(Schema.Union(members, { mode: representation.mode }), representation, path)
+        return finishStructural(Schema.Union(members, representation.options), representation, path)
       }
     }
   }

package/src/internal/schema/{schema.ts → make.ts}

@@ -2,50 +2,10 @@ import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
 import * as SchemaParser from "../../SchemaParser.ts"
-import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 
 /** @internal */
 export const TypeId = "~effect/Schema/Schema"
 
-/** @internal */
-export function makeDeclarationReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.DeclarationReviver<P>["revive"]
-): SchemaRepresentation.DeclarationReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
-/** @internal */
-export function makeFilterReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.FilterReviver<P>["revive"]
-): SchemaRepresentation.FilterReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
-/** @internal */
-export function makeFilterGroupReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.FilterGroupReviver<P>["revive"]
-): SchemaRepresentation.FilterGroupReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
 const SchemaProto = {
   [TypeId]: TypeId,
   pipe() {

package/src/internal/schema/parser.ts

@@ -2,21 +2,29 @@ import * as Exit from "../../Exit.ts"
 import * as Option from "../../Option.ts"
 import { args } from "../core.ts"
 
+/** @internal */
 export const missing = Symbol()
 
+/** @internal */
 export { args }
 
+/** @internal */
 export type Success<A, E = never> = Exit.Success<A, E> & { readonly [args]: A }
 
+/** @internal */
 export const succeed = Exit.succeed as <A>(value: A) => Success<A>
 
+/** @internal */
 export const missingExit = succeed(missing)
 
 // Shared success for a present input returned unchanged. It must be resolved
 // before crossing an asynchronous or transformation boundary.
+/** @internal */
 export const sameExit: Success<unknown> = succeed(missing)
 
+/** @internal */
 export const toOption = <A>(value: A): Option.Option<A> => value === missing ? Option.none() : Option.some(value as A)
 
+/** @internal */
 export const fromOptionExit = <A>(option: Option.Option<A>): Success<A | typeof missing> =>
   option._tag === "None" ? missingExit : succeed(option.value)

package/src/internal/schema/standardSchema.ts

@@ -0,0 +1,125 @@
+import * as Cause from "../../Cause.ts"
+import * as Effect from "../../Effect.ts"
+import * as Exit from "../../Exit.ts"
+import * as JsonSchema from "../../JsonSchema.ts"
+import * as Scheduler from "../../Scheduler.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "../../StandardSchema.ts"
+import * as InternalToCodec from "./toCodec.ts"
+import * as InternalToJsonSchemaDocument from "./toJsonSchemaDocument.ts"
+import * as InternalToRepresentation from "./toRepresentation.ts"
+
+function makeStandardResult<A>(exit: Exit.Exit<StandardSchemaV1.Result<A>>): StandardSchemaV1.Result<A> {
+  return Exit.isSuccess(exit) ? exit.value : {
+    issues: [{ message: Cause.pretty(exit.cause) }]
+  }
+}
+
+/** @internal */
+export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
+  self: S,
+  options?: {
+    readonly leafHook?: SchemaIssue.LeafHook | undefined
+    readonly checkHook?: SchemaIssue.CheckHook | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
+  }
+): StandardSchemaV1<S["Encoded"], S["Type"]> & S {
+  const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(self) as (
+    input: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<S["Type"], SchemaIssue.Issue>
+  const parseOptions: SchemaAST.ParseOptions = { errors: "all", ...options?.parseOptions }
+  const formatter = SchemaIssue.makeFormatterStandardSchemaV1(options)
+  const validate: StandardSchemaV1<S["Encoded"], S["Type"]>["~standard"]["validate"] = (value: unknown) => {
+    const scheduler = new Scheduler.MixedScheduler("sync")
+    const fiber = Effect.runFork(
+      Effect.match(decodeUnknownEffect(value, parseOptions), {
+        onFailure: formatter,
+        onSuccess: (value): StandardSchemaV1.Result<S["Type"]> => ({ value })
+      }),
+      { scheduler }
+    )
+    fiber.currentDispatcher?.flush()
+    const exit = fiber.pollUnsafe()
+    if (exit) {
+      return makeStandardResult(exit)
+    }
+    return new Promise((resolve) => {
+      fiber.addObserver((exit) => {
+        resolve(makeStandardResult(exit))
+      })
+    })
+  }
+  if ("~standard" in self) {
+    const out = self as any
+    if ("validate" in out["~standard"]) return out
+    Object.assign(out["~standard"], { validate })
+    return out
+  }
+  return Object.assign(self, {
+    "~standard": {
+      version: 1,
+      vendor: "effect",
+      validate
+    } as const
+  })
+}
+
+function toJsonSchemaDocument(ast: SchemaAST.AST): JsonSchema.Document<"draft-2020-12"> {
+  const document = InternalToRepresentation.toRepresentation(
+    InternalToCodec.toCodecJsonAST(ast)
+  )
+  return InternalToJsonSchemaDocument.toJsonSchemaDocument(document)
+}
+
+function toBaseStandardJSONSchemaV1(
+  ast: SchemaAST.AST,
+  target: StandardJSONSchemaV1.Target
+): JsonSchema.JsonSchema {
+  const doc2020_12 = toJsonSchemaDocument(ast)
+  if (target === "draft-2020-12") {
+    const schema = doc2020_12.schema
+    if (Object.keys(doc2020_12.definitions).length > 0) {
+      schema.$defs = doc2020_12.definitions
+    }
+    return schema
+  } else if (target === "draft-07") {
+    const doc07 = JsonSchema.toDocumentDraft07(doc2020_12)
+    const schema = doc07.schema
+    if (Object.keys(doc07.definitions).length > 0) {
+      schema.definitions = doc07.definitions
+    }
+    return schema
+  }
+  throw new globalThis.Error(`Unsupported target: ${target}`)
+}
+
+/** @internal */
+export function toStandardJSONSchemaV1<S extends Schema.Constraint>(
+  self: S
+): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S {
+  const jsonSchema: StandardJSONSchemaV1.Props<S["Encoded"], S["Type"]>["jsonSchema"] = {
+    input(options) {
+      return toBaseStandardJSONSchemaV1(self.ast, options.target)
+    },
+    output(options) {
+      return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
+    }
+  }
+  if ("~standard" in self) {
+    const out = self as any
+    if ("jsonSchema" in out["~standard"]) return out
+    Object.assign(out["~standard"], { jsonSchema })
+    return out
+  }
+  return Object.assign(self, {
+    "~standard": {
+      version: 1,
+      vendor: "effect",
+      jsonSchema
+    } as const
+  })
+}

package/src/internal/schema/toCodeDocument.ts

@@ -45,7 +45,7 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
     if (rendered === undefined) return undefined
     entries.push(`${formatPropertyKey(key)}: ${rendered}`)
   }
-  return `{ ${entries.join(", ")} }`
+  return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
 function renderAnnotations(
@@ -330,6 +330,11 @@ export function toCodeDocument(
     return rendered === undefined ? "" : `.${method}(${rendered})`
   }
 
+  function unionOptionsRuntime(options: NonNullable<SchemaRepresentation.Union["options"]>): string {
+    if (!Object.hasOwn(options, "mode")) return "{}"
+    return `{ mode: ${options.mode === undefined ? "undefined" : format(options.mode)} }`
+  }
+
   function compileCheck(
     check: SchemaRepresentation.Check,
     path: Path
@@ -483,25 +488,29 @@ export function toCodeDocument(
           )
         })
         const rest = representation.rest.map((item, index) => recur(item, [...path, "rest", index]))
+        let code: SchemaRepresentation.Code
         if (Arr.isArrayNonEmpty(rest)) {
           const item = rest[0]
           if (elements.length === 0 && rest.length === 1) {
-            return makeCode(`Schema.Array(${item.runtime})`, `ReadonlyArray<${item.Type}>`)
+            code = makeCode(`Schema.Array(${item.runtime})`, `ReadonlyArray<${item.Type}>`)
+          } else {
+            const post = rest.slice(1)
+            code = makeCode(
+              `Schema.TupleWithRest(Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}]), [${
+                rest.map((item) => item.runtime).join(", ")
+              }])`,
+              `readonly [${elements.map((element) => element.Type).join(", ")}, ...Array<${item.Type}>${
+                post.length > 0 ? `, ${post.map((item) => item.Type).join(", ")}` : ""
+              }]`
+            )
           }
-          const post = rest.slice(1)
-          return makeCode(
-            `Schema.TupleWithRest(Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}]), [${
-              rest.map((item) => item.runtime).join(", ")
-            }])`,
-            `readonly [${elements.map((element) => element.Type).join(", ")}, ...Array<${item.Type}>${
-              post.length > 0 ? `, ${post.map((item) => item.Type).join(", ")}` : ""
-            }]`
+        } else {
+          code = makeCode(
+            `Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}])`,
+            `readonly [${elements.map((element) => element.Type).join(", ")}]`
           )
         }
-        return makeCode(
-          `Schema.Tuple([${elements.map((element) => element.runtime).join(", ")}])`,
-          `readonly [${elements.map((element) => element.Type).join(", ")}]`
-        )
+        return code
       }
       case "Objects": {
         const properties = representation.propertySignatures.map((property, index) => {
@@ -513,52 +522,55 @@ export function toCodeDocument(
           let runtime = type.runtime
           if (property.isMutable) runtime = `Schema.mutableKey(${runtime})`
           if (property.isOptional) runtime = `Schema.optionalKey(${runtime})`
+          runtime += runtimeAnnotate(property.annotations, "annotateKey")
           const runtimeName = isSymbol ? `[${name}]` : name
           const typeName = `${property.isMutable ? "" : "readonly "}${runtimeName}${property.isOptional ? "?" : ""}`
-          return makeCode(
-            `${runtimeName}: ${runtime}${runtimeAnnotate(property.annotations, "annotateKey")}`,
-            `${typeName}: ${type.Type}`
-          )
+          return {
+            code: makeCode(`${runtimeName}: ${runtime}`, `${typeName}: ${type.Type}`)
+          }
         })
         const indexSignatures = representation.indexSignatures.map((signature, index) => ({
           parameter: recur(signature.parameter, [...path, "indexSignatures", index, "parameter"]),
           type: recur(signature.type, [...path, "indexSignatures", index, "type"])
         }))
-        const propertyRuntimes = properties.map((property) => property.runtime).join(", ")
-        const propertyTypes = properties.map((property) => property.Type).join(", ")
+        const propertyRuntimes = properties.map((property) => property.code.runtime).join(", ")
+        const propertyTypes = properties.map((property) => property.code.Type).join(", ")
+        let code: SchemaRepresentation.Code
         if (indexSignatures.length === 0) {
-          return makeCode(
+          code = makeCode(
             `Schema.Struct({ ${propertyRuntimes} })`,
             `{ ${propertyTypes} }`
           )
-        }
-        if (properties.length === 0 && indexSignatures.length === 1) {
+        } else if (properties.length === 0 && indexSignatures.length === 1) {
           const signature = indexSignatures[0]
-          return makeCode(
+          code = makeCode(
             `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`,
             `{ readonly [x: ${signature.parameter.Type}]: ${signature.type.Type} }`
           )
-        }
-        const indexRuntimes = indexSignatures.map((signature) =>
-          `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`
-        ).join(", ")
-        const indexTypes = indexSignatures.map((signature) =>
-          `readonly [x: ${signature.parameter.Type}]: ${signature.type.Type}`
-        )
-        if (properties.length === 0) {
-          return makeCode(
-            `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
-            `{ ${indexTypes.join(", ")} }`
+        } else {
+          const indexRuntimes = indexSignatures.map((signature) =>
+            `Schema.Record(${signature.parameter.runtime}, ${signature.type.runtime})`
+          ).join(", ")
+          const indexTypes = indexSignatures.map((signature) =>
+            `readonly [x: ${signature.parameter.Type}]: ${signature.type.Type}`
           )
+          code = properties.length === 0
+            ? makeCode(
+              `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
+              `{ ${indexTypes.join(", ")} }`
+            )
+            : makeCode(
+              `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
+              [`{ ${propertyTypes} }`, ...indexTypes.map((indexType) => `{ ${indexType} }`)].join(" & ")
+            )
         }
-        return makeCode(
-          `Schema.StructWithRest(Schema.Struct({ ${propertyRuntimes} }), [${indexRuntimes}])`,
-          [`{ ${propertyTypes} }`, ...indexTypes.map((indexType) => `{ ${indexType} }`)].join(" & ")
-        )
+        return code
       }
       case "Union": {
-        if (representation.types.length === 0) return makeCode("Schema.Never", "never")
-        if (representation.types.every(isSimpleLiveLiteral)) {
+        if (representation.options === undefined && representation.types.length === 0) {
+          return makeCode("Schema.Never", "never")
+        }
+        if (representation.options === undefined && representation.types.every(isSimpleLiveLiteral)) {
           const literals = representation.types.map((literal) => format(literal.literal))
           return literals.length === 1
             ? makeCode(`Schema.Literal(${literals[0]})`, literals[0])
@@ -567,10 +579,12 @@ export function toCodeDocument(
         const types = representation.types.map((type, index) =>
           recur(type, [...path, "types", index], includeTypeBrands)
         )
-        const mode = representation.mode === "anyOf" ? "" : `, { mode: "oneOf" }`
+        const options = representation.options === undefined
+          ? ""
+          : `, ${unionOptionsRuntime(representation.options)}`
         return makeCode(
-          `Schema.Union([${types.map((type) => type.runtime).join(", ")}]${mode})`,
-          types.map((type) => type.Type).join(" | ")
+          `Schema.Union([${types.map((type) => type.runtime).join(", ")}]${options})`,
+          types.length === 0 ? "never" : types.map((type) => type.Type).join(" | ")
         )
       }
     }