@effect-app/vue 4.0.0-beta.99 → 4.0.0

package/src/confirm.ts

@@ -1,5 +1,7 @@
-import { Context, Effect, Layer } from "effect-app"
-import { I18n } from "./intl.js"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { I18n } from "./intl.ts"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class Confirm extends Context.Service<Confirm>()("Confirm", {
@@ -21,16 +23,12 @@ export class Confirm extends Context.Service<Confirm>()("Confirm", {
   static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
   static readonly Default = this.DefaultWithoutDependencies
 
-  static confirm(message?: string) {
-    return Effect.gen(function*() {
-      const c = yield* Confirm
-      return yield* c.confirm(message)
-    })
-  }
-  static confirmOrInterrupt(message?: string) {
-    return Effect.gen(function*() {
-      const c = yield* Confirm
-      return yield* c.confirmOrInterrupt(message)
-    })
-  }
+  static readonly confirm = Effect.fnUntraced(function*(message?: string) {
+    const c = yield* Confirm
+    return yield* c.confirm(message)
+  })
+  static readonly confirmOrInterrupt = Effect.fnUntraced(function*(message?: string) {
+    const c = yield* Confirm
+    return yield* c.confirmOrInterrupt(message)
+  })
 }

package/src/dependencyMetadata.ts

@@ -0,0 +1,84 @@
+import { DataDependencies } from "effect-app/client"
+import * as Hash from "effect/Hash"
+
+// Maps a live query's reactivity key (its full `[...queryKey, input]` key) to the
+// data dependencies it read while fetching. Populated when the query handler resolves and
+// cleared when the query atom is GC'd, so the set mirrors the live query atoms (mounted or
+// cached-within-ttl) — the atom equivalent of the former tanstack query cache.
+type Entry = { readonly key: ReadonlyArray<unknown>; readonly reads: DataDependencies.DataDependencies }
+const readDependencies = new Map<number, Entry>()
+export type QueryInvalidationMode = "await" | "soft"
+type InvalidationModeEntry = { awaitSubscribers: number; softSubscribers: number }
+const invalidationModes = new Map<number, InvalidationModeEntry>()
+
+export const registerQueryInvalidationMode = (
+  key: ReadonlyArray<unknown>,
+  mode: QueryInvalidationMode
+): () => void => {
+  const hash = Hash.hash(key)
+  const entry = invalidationModes.get(hash) ?? { awaitSubscribers: 0, softSubscribers: 0 }
+  if (mode === "soft") entry.softSubscribers++
+  else entry.awaitSubscribers++
+  invalidationModes.set(hash, entry)
+  let active = true
+  return () => {
+    if (!active) return
+    active = false
+    if (mode === "soft") entry.softSubscribers--
+    else entry.awaitSubscribers--
+    if (entry.awaitSubscribers === 0 && entry.softSubscribers === 0) invalidationModes.delete(hash)
+  }
+}
+
+export const getQueryInvalidationMode = (key: ReadonlyArray<unknown>): QueryInvalidationMode => {
+  const entry = invalidationModes.get(Hash.hash(key))
+  return entry !== undefined && entry.awaitSubscribers === 0 && entry.softSubscribers > 0 ? "soft" : "await"
+}
+
+export const setQueryReadDependencies = (
+  key: ReadonlyArray<unknown>,
+  reads: DataDependencies.DataDependencies
+) => {
+  const h = Hash.hash(key)
+  if (!DataDependencies.isNonEmpty(reads)) readDependencies.delete(h)
+  else readDependencies.set(h, { key, reads })
+}
+
+export const clearQueryReadDependencies = (key: ReadonlyArray<unknown>) => {
+  readDependencies.delete(Hash.hash(key))
+}
+
+export const getQueryReadDependencies = (
+  key: ReadonlyArray<unknown>
+): DataDependencies.DataDependencies => readDependencies.get(Hash.hash(key))?.reads ?? DataDependencies.empty()
+
+/**
+ * Reactivity keys of every live query whose recorded read-dependencies intersect this
+ * mutation's `writeDependencies`. Returned keys are passed to `invalidateAndAwait`, refreshing
+ * exactly those queries.
+ */
+export const getDerivedInvalidationKeys = (
+  writeDependencies: DataDependencies.DataDependencies
+): ReadonlyArray<ReadonlyArray<unknown>> => {
+  if (!DataDependencies.isNonEmpty(writeDependencies)) return []
+  const keys: Array<ReadonlyArray<unknown>> = []
+  for (const { key, reads } of readDependencies.values()) {
+    if (DataDependencies.intersects(reads, writeDependencies)) keys.push(key)
+  }
+  return keys
+}
+
+export const partitionInvalidationKeys = (
+  keys: ReadonlyArray<ReadonlyArray<unknown>>
+): {
+  readonly awaitKeys: ReadonlyArray<ReadonlyArray<unknown>>
+  readonly softKeys: ReadonlyArray<ReadonlyArray<unknown>>
+} => {
+  const awaitKeys: Array<ReadonlyArray<unknown>> = []
+  const softKeys: Array<ReadonlyArray<unknown>> = []
+  for (const key of keys) {
+    if (getQueryInvalidationMode(key) === "soft") softKeys.push(key)
+    else awaitKeys.push(key)
+  }
+  return { awaitKeys, softKeys }
+}

package/src/errorReporter.ts

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import * as Sentry from "@sentry/browser"
-import { Cause, Effect, type LogLevel } from "effect-app"
 import { CauseException, tryToJson, tryToReport } from "effect-app/client/errors"
+import * as Effect from "effect-app/Effect"
 import { dropUndefined, LogLevelToSentry } from "effect-app/utils"
+import * as Cause from "effect/Cause"
+import type * as LogLevel from "effect/LogLevel"
 
 export const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseException<E> => {
   try {
@@ -13,45 +15,41 @@ export const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): Cause
   }
 }
 
-export function reportError(
-  name: string
-) {
-  return (
-    cause: Cause.Cause<unknown>,
-    extras?: Record<string, unknown>,
-    level: LogLevel.Severity = "Error"
-  ): Effect.Effect<unknown, never, never> =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* Effect.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
-          return Cause.squash(cause)
-        }
-
-        const error = tryCauseException(cause, name)
-        yield* reportSentry(error, extras, LogLevelToSentry(level))
-        yield* Effect
-          .logWithLevel(level)("Reporting error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              error: tryToReport(error),
-              cause: tryToJson(cause),
-              __error_name__: name
-            })),
-            Effect.catchCause((cause) => Effect.logWarning("Failed to log error", cause)),
-            Effect.catchCause(() => Effect.logFatal("Failed to log error cause"))
-          )
+export function reportError(name: string) {
+  return Effect.fnUntraced(
+    function*(
+      cause: Cause.Cause<unknown>,
+      extras?: Record<string, unknown>,
+      level: LogLevel.Severity = "Error"
+    ) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* Effect.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return Cause.squash(cause)
+      }
 
-        return error
-      })
-      .pipe(
-        Effect.tapCause((cause) =>
-          Effect.logError("Failed to report error", cause).pipe(
-            Effect.tapCause(() => Effect.logFatal("Failed to log error cause"))
-          )
+      const error = tryCauseException(cause, name)
+      yield* reportSentry(error, extras, LogLevelToSentry(level))
+      yield* Effect
+        .logWithLevel(level)("Reporting error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            error: tryToReport(error),
+            cause: tryToJson(cause),
+            __error_name__: name
+          })),
+          Effect.catchCause((cause) => Effect.logWarning("Failed to log error", cause)),
+          Effect.catchCause(() => Effect.logFatal("Failed to log error cause"))
         )
-      )
+
+      return error
+    },
+    (effect) =>
+      Effect.tapCause(effect, (cause) =>
+        Effect.logError("Failed to report error", cause).pipe(
+          Effect.tapCause(() => Effect.logFatal("Failed to log error cause"))
+        ))
+  )
 }
 
 function reportSentry(
@@ -63,39 +61,33 @@ function reportSentry(
     const scope = new Sentry.Scope()
     scope.setLevel(level)
     if (extras) scope.setContext("extras", extras)
-    scope.setContext("error", tryToReport(error) as any)
-    scope.setContext("cause", tryToJson(error.originalCause) as any)
+    scope.setContext("error", tryToReport(error))
+    scope.setContext("cause", tryToJson(error.originalCause))
     Sentry.captureException(error, scope)
   })
 }
 
-export function logError<E>(
-  name: string
-) {
-  return (cause: Cause.Cause<E>, extras?: Record<string, unknown>) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* Effect.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
-          return
-        }
-        yield* Effect
-          .logWarning("Logging error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-      })
-      .pipe(
-        Effect.tapCause((cause) =>
-          Effect.logError("Failed to log error", cause).pipe(
-            Effect.tapCause(() => Effect.logFatal("Failed to log error cause"))
-          )
-        )
-      )
+export function logError<E>(name: string) {
+  return Effect.fnUntraced(
+    function*(cause: Cause.Cause<E>, extras?: Record<string, unknown>) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* Effect.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
+        return
+      }
+      yield* Effect
+        .logWarning("Logging error", cause)
+        .pipe(Effect.annotateLogs(dropUndefined({
+          extras,
+          cause: tryToJson(cause),
+          __error_name__: name
+        })))
+    },
+    (effect) =>
+      Effect.tapCause(effect, (cause) =>
+        Effect.logError("Failed to log error", cause).pipe(
+          Effect.tapCause(() => Effect.logFatal("Failed to log error cause"))
+        ))
+  )
 }
 
 export function captureException(error: unknown, extras?: Record<string, unknown>) {
@@ -105,12 +97,10 @@ export function captureException(error: unknown, extras?: Record<string, unknown
   console.error(error, extras)
 }
 
-export function reportMessage(message: string, extras?: Record<string, unknown>) {
-  return Effect.gen(function*() {
-    const scope = new Sentry.Scope()
-    if (extras) scope.setContext("extras", extras)
-    Sentry.captureMessage(message, scope)
+export const reportMessage = Effect.fnUntraced(function*(message: string, extras?: Record<string, unknown>) {
+  const scope = new Sentry.Scope()
+  if (extras) scope.setContext("extras", extras)
+  Sentry.captureMessage(message, scope)
 
-    console.warn(message, extras)
-  })
-}
+  console.warn(message, extras)
+})

package/src/form.ts

@@ -1,8 +1,12 @@
 import { createIntl, type IntlFormatters } from "@formatjs/intl"
-import type {} from "intl-messageformat"
-import { Cause, Exit, Option, pipe, S } from "effect-app"
+
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
 import type { Unbranded } from "effect-app/Schema/brand"
 import type { IsUnion } from "effect-app/utils"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import { pipe } from "effect/Function"
 import { capitalize, ref } from "vue"
 
 // type GetSchemaFromProp<T> = T extends Field<infer S, any, any, any> ? S
@@ -23,7 +27,7 @@ function getObjectsAST(ast: S.AST.AST): S.AST.Objects | null {
 }
 
 /** @deprecated Use OmegaForm instead */
-export function convertIn(v: string | null, type?: "text" | "float" | "int") {
+export function convertIn(v: number | string | null, type?: "text" | "float" | "int") {
   return v === null ? "" : type === "text" ? v : `${v}`
 }
 
@@ -76,7 +80,8 @@ export interface DiscriminatedUnionFieldInfo<T> {
 }
 
 export type NestedFieldInfoKey<Key> = [Key] extends [Record<PropertyKey, any>]
-  ? Unbranded<Key> extends Record<PropertyKey, any> ? NestedFieldInfo<Key>
+  ? Unbranded<Key> extends (string | number | boolean | bigint | symbol) ? FieldInfo<Key>
+  : Unbranded<Key> extends Record<PropertyKey, any> ? NestedFieldInfo<Key>
   : FieldInfo<Key>
   : FieldInfo<Key>
 
@@ -262,12 +267,12 @@ function buildFieldInfo(
   const propertyKey = property.name
   const schema = S.make<S.Codec<unknown>>(property.type)
   const metadata = getMetadataFromSchema(property.type)
-  const parse = S.decodeUnknownExit(schema as S.Codec<unknown> & { readonly DecodingServices: never })
+  const parse = S.decodeUnknownExit(schema)
 
   const nullableOrUndefined = S.AST.isUnion(property.type)
     && (property.type.types.includes(S.Null.ast) || property.type.types.some((_) => _._tag === "Undefined"))
   const realSelf = nullableOrUndefined && S.AST.isUnion(property.type)
-    ? property.type.types.filter((_) => _ !== S.Null.ast && _._tag !== "Undefined")[0]!
+    ? property.type.types.find((_) => _ !== S.Null.ast && _._tag !== "Undefined")!
     : property.type
   const id = S.AST.resolveIdentifier(property.type)
   const id2 = S.AST.resolveIdentifier(realSelf)
@@ -284,20 +289,22 @@ function buildFieldInfo(
       return custom(err, e, v)
     }
 
-    // parse specific error types for better translation support
-    const integerMatch = err.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
+    // parse specific error types for better translation support.
+    // beta.107 formatters often omit ", actual/got <value>" from the issue string;
+    // fall back to the rejected input `v` when the regex has no capture.
+    const integerMatch = err.match(/Expected.*integer(?:.*(?:actual|got)\s+([^)\s]+))?/i)
     if (integerMatch) {
       return translate.value(
         { defaultMessage: "Expected an integer, actual {actualValue}", id: "validation.integer.expected" },
-        { actualValue: integerMatch[1] }
+        { actualValue: integerMatch[1] ?? String(v) }
       )
     }
 
-    const numberMatch = err.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
+    const numberMatch = err.match(/Expected.*number(?:.*(?:actual|got)\s+([^)\s]+))?/i)
     if (numberMatch) {
       return translate.value(
         { defaultMessage: "Expected a number, actual {actualValue}", id: "validation.number.expected" },
-        { actualValue: numberMatch[1] }
+        { actualValue: numberMatch[1] ?? String(v) }
       )
     }
 
@@ -384,7 +391,7 @@ function buildFieldInfo(
       : metadata.type === "float" || metadata.type === "int"
       ? numberRules
       : []) as UnknownRule[],
-    parseRule as UnknownRule
+    parseRule
   ]
 
   const info = {
@@ -451,20 +458,20 @@ export function getMetadataFromSchema(
 
   const nullable = S.AST.isUnion(ast) && ast.types.includes(S.Null.ast)
   const realSelf = nullable && S.AST.isUnion(ast)
-    ? ast.types.filter((_) => _ !== S.Null.ast)[0]!
+    ? ast.types.find((_) => _ !== S.Null.ast)!
     : ast
 
   let jschema: any
   try {
     const doc = S.toJsonSchemaDocument(S.make<S.Codec<unknown>>(realSelf))
     jschema = doc.schema as any
-    const defs = doc.definitions as Record<string, any>
+    const defs = doc.definitions
     // resolve $ref against definitions
     while (jschema["$ref"] && jschema["$ref"].startsWith("#/$defs/")) {
       const { $ref: _, ...rest } = jschema
       jschema = { ...defs[jschema["$ref"].replace("#/$defs/", "")], ...rest }
     }
-  } catch (_err) {
+  } catch {
     jschema = {}
   }
   // or we need to add these info directly in the refinement like the minimum

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from "./lib.js"
+export * from "./lib.ts"
 
-export * from "./makeClient.js"
-export * from "./makeContext.js"
-export * from "./makeIntl.js"
-export * from "./mutate.js"
-export * from "./query.js"
-export * from "./runtime.js"
+export * from "./makeClient.ts"
+export * from "./makeContext.ts"
+export * from "./makeIntl.ts"
+export * from "./mutate.ts"
+export * from "./query.ts"
+export * from "./runtime.ts"