effect 4.0.6 → 4.1.0

package/src/internal/jsonSchema.ts

@@ -0,0 +1,27 @@
+/** @internal */
+export function getSubschemaKind(keyword: string): "schema" | "map" | "array" | undefined {
+  switch (keyword) {
+    case "$defs":
+    case "properties":
+    case "patternProperties":
+    case "dependentSchemas":
+      return "map"
+    case "allOf":
+    case "anyOf":
+    case "oneOf":
+    case "prefixItems":
+      return "array"
+    case "not":
+    case "additionalProperties":
+    case "propertyNames":
+    case "unevaluatedProperties":
+    case "items":
+    case "contains":
+    case "unevaluatedItems":
+    case "if":
+    case "then":
+    case "else":
+    case "contentSchema":
+      return "schema"
+  }
+}

package/src/internal/matcher.ts

@@ -140,7 +140,7 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
     const len = predicates.length
 
     return (u: unknown) => {
-      if (!Array.isArray(u)) {
+      if (!Array.isArray(u) || u.length < len) {
         return false
       }
 
@@ -511,6 +511,23 @@ export const tags = discriminators("_tag")
 /** @internal */
 export const tagsExhaustive = discriminatorsExhaustive("_tag")
 
+/** @internal */
+export const literals = (fields: object) => {
+  const predicate = makeWhen(
+    (arg: any) =>
+      (typeof arg === "string" || typeof arg === "number") && Object.hasOwn(fields, arg) &&
+      (fields as any)[arg] !== undefined,
+    (data: any) => (fields as any)[data](data)
+  )
+  return (self: any): any => self.add(predicate)
+}
+
+/** @internal */
+export const literalsExhaustive = (fields: object) => {
+  const addCases = literals(fields)
+  return (matcher: any): any => exhaustive(addCases(matcher))
+}
+
 /** @internal */
 export const not = <
   R,

package/src/internal/persistence.ts

@@ -1,2 +1,13 @@
 /** @internal */
 export const sqlCleanupBatchSize = 1000
+
+/**
+ * Key prefix for a persistence store. The store id is escaped so the namespace
+ * always ends at its first `:`, and distinct store / key pairs never collide.
+ *
+ * @internal
+ */
+export const storeNamespace = (storeId: string): string => `${storeId.replace(/%/g, "%25").replace(/:/g, "%3A")}:`
+
+/** @internal */
+export const escapeRedisGlob = (pattern: string): string => pattern.replace(/[\\*?[\]]/g, "\\$&")

package/src/internal/rcRef.ts

@@ -225,7 +225,10 @@ const release = <A, E>(self: RcRefImpl<A, E>, state: State.Acquired<A>): Effect.
     Effect.flatMap(restore(Effect.sleep(idleTimeToLive)), () => {
       if (self.state === state && state.refCount === 0) {
         self.state = stateEmpty
-        return Scope.close(state.scope, Exit.void)
+        return Effect.ignoreCause(Scope.close(state.scope, Exit.void), {
+          log: "Unhandled",
+          message: "Unhandled error in RcRef finalizer"
+        })
       }
       return Effect.void
     })

package/src/internal/schema/compilerRegistry.ts

@@ -58,6 +58,7 @@ export interface Entry {
   readonly is?: Is | undefined
   readonly decode?: Decode | undefined
   readonly make?: Make | undefined
+  readonly compiledMakeEffect?: Parser | undefined
   readonly decodeEffect: Parser
   readonly parser: Parser
   readonly makeEffect: Parser
@@ -117,6 +118,10 @@ class CompilerEntry extends InterpretedEntry {
     return this.save("make", this.operation("make"))
   }
 
+  get compiledMakeEffect(): Parser | undefined {
+    return this.save("compiledMakeEffect", this.operation("makeEffect"))
+  }
+
   override get decodeEffect(): Parser {
     return this.save(
       "decodeEffect",
@@ -132,7 +137,7 @@ class CompilerEntry extends InterpretedEntry {
   }
 
   override get makeEffect(): Parser {
-    const makeEffect = this.operation("makeEffect")
+    const makeEffect = this.compiledMakeEffect
     if (makeEffect !== undefined) return this.save("makeEffect", makeEffect)
     const child = (ast: SchemaAST.AST): Parser => lazyParser(this.resolve, ast, "makeEffect")
     return this.save(

package/src/internal/schema/content.ts

@@ -0,0 +1,18 @@
+const ContentTypeId = Symbol.for("~effect/Schema/content")
+
+/** @internal */
+export interface Content {
+  readonly mediaType: string
+  readonly preserveSchema: boolean
+}
+
+/** @internal */
+export function setContent<A extends object>(operation: A, content: Content): A {
+  Object.defineProperty(operation, ContentTypeId, { value: content })
+  return operation
+}
+
+/** @internal */
+export function getContent(operation: object): Content | undefined {
+  return (operation as { readonly [ContentTypeId]?: Content })[ContentTypeId]
+}