@effect-app/vue 4.0.0-beta.22 → 4.0.0-beta.221

package/src/{experimental/confirm.ts → confirm.ts}

@@ -1,8 +1,10 @@
-import { Effect, Layer, ServiceMap } from "effect-app"
+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.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class Confirm extends ServiceMap.Service<Confirm>()("Confirm", {
+export class Confirm extends Context.Service<Confirm>()("Confirm", {
   make: Effect.gen(function*() {
     const { intl } = yield* I18n
 
@@ -21,16 +23,12 @@ export class Confirm extends ServiceMap.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/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
@@ -22,7 +26,8 @@ function getObjectsAST(ast: S.AST.AST): S.AST.Objects | null {
   return null
 }
 
-export function convertIn(v: string | null, type?: "text" | "float" | "int") {
+/** @deprecated Use OmegaForm instead */
+export function convertIn(v: number | string | null, type?: "text" | "float" | "int") {
   return v === null ? "" : type === "text" ? v : `${v}`
 }
 
@@ -30,8 +35,10 @@ export function convertIn(v: string | null, type?: "text" | "float" | "int") {
  * Makes sure our international number format is converted to js int/float format.
  * Right now assumes . for thousands and , for decimal.
  */
+/** @deprecated Use OmegaForm instead */
 export const prepareNumberForLocale = (v: string) => v.replace(/\./g, "").replace(/,/g, ".")
 
+/** @deprecated Use OmegaForm instead */
 export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   v = v == null ? v : v.trim()
   const c = v === ""
@@ -49,6 +56,7 @@ export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   return c
 }
 
+/** @deprecated Use OmegaForm instead */
 export function convertOut(v: string, set: (v: {} | null) => void, type?: "text" | "float" | "int") {
   return set(convertOutInt(v, type))
 }
@@ -72,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>
 
@@ -143,10 +152,18 @@ function handlePropertySignature(
             const typeLiteral = getObjectsAST(ps.type)
 
             const tagPropertySignature = typeLiteral?.propertySignatures.find((_) => _.name === "_tag")
-            const tagLiteral = tagPropertySignature
-                && S.AST.isLiteral(tagPropertySignature.type)
-                && typeof tagPropertySignature.type.literal === "string"
-              ? tagPropertySignature.type.literal
+            // unwrap single-element Union to Literal (S.Struct({ _tag: S.Literal("x") }) wraps as Union([Literal("x")]))
+            const tagType = tagPropertySignature
+              ? S.AST.isUnion(tagPropertySignature.type)
+                  && tagPropertySignature.type.types.length === 1
+                  && S.AST.isLiteral(tagPropertySignature.type.types[0]!)
+                ? tagPropertySignature.type.types[0]
+                : tagPropertySignature.type
+              : undefined
+            const tagLiteral = tagType
+                && S.AST.isLiteral(tagType)
+                && typeof tagType.literal === "string"
+              ? tagType.literal
               : void 0
 
             const toRet = handlePropertySignature(ps)
@@ -189,6 +206,7 @@ function handlePropertySignature(
   }
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFields<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>
@@ -198,6 +216,7 @@ export function buildFieldInfoFromFields<
   return buildFieldInfoFromFieldsRoot(schema).fields
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFieldsRoot<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
@@ -235,7 +254,9 @@ abstract class PhantomTypeParameter<
 
 const defaultIntl = createIntl({ locale: "en" })
 
+/** @deprecated Use OmegaForm instead */
 export const translate = ref<IntlFormatters["formatMessage"]>(defaultIntl.formatMessage)
+/** @deprecated Use OmegaForm instead */
 export const customSchemaErrors = ref<Map<S.AST.AST | string, (message: string, e: unknown, v: unknown) => string>>(
   new Map()
 )
@@ -246,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)
@@ -269,7 +290,7 @@ function buildFieldInfo(
     }
 
     // parse specific error types for better translation support
-    const integerMatch = err.match(/Expected.*integer.*actual\s+(.+)/i)
+    const integerMatch = err.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
     if (integerMatch) {
       return translate.value(
         { defaultMessage: "Expected an integer, actual {actualValue}", id: "validation.integer.expected" },
@@ -277,7 +298,7 @@ function buildFieldInfo(
       )
     }
 
-    const numberMatch = err.match(/Expected.*number.*actual\s+(.+)/i)
+    const numberMatch = err.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
     if (numberMatch) {
       return translate.value(
         { defaultMessage: "Expected a number, actual {actualValue}", id: "validation.number.expected" },
@@ -368,7 +389,7 @@ function buildFieldInfo(
       : metadata.type === "float" || metadata.type === "int"
       ? numberRules
       : []) as UnknownRule[],
-    parseRule as UnknownRule
+    parseRule
   ]
 
   const info = {
@@ -398,6 +419,7 @@ function buildFieldInfo(
   return info as any
 }
 
+/** @deprecated Use OmegaForm instead */
 export function getMetadataFromSchema(
   ast: S.AST.AST
 ): {
@@ -411,22 +433,43 @@ export function getMetadataFromSchema(
   required: boolean
   description?: string
 } {
+  const findJsonSchemaType = (
+    schema: any,
+    target: "number" | "integer"
+  ): boolean => {
+    if (!schema || typeof schema !== "object") {
+      return false
+    }
+
+    if (schema.type === target) {
+      return true
+    }
+
+    if (Array.isArray(schema.type) && schema.type.includes(target)) {
+      return true
+    }
+
+    return ["anyOf", "oneOf", "allOf"].some((key) =>
+      Array.isArray(schema[key]) && schema[key].some((member: any) => findJsonSchemaType(member, target))
+    )
+  }
+
   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
@@ -440,8 +483,8 @@ export function getMetadataFromSchema(
   //         "title": "Int"
   //     }
   // }
-  const isNumber = jschema.type === "number" || jschema.type === "integer"
-  const isInt = jschema.type === "integer"
+  const isInt = findJsonSchemaType(jschema, "integer")
+  const isNumber = isInt || findJsonSchemaType(jschema, "number")
   return {
     type: isInt ? "int" as const : isNumber ? "float" as const : "text" as const,
     minimum: jschema.minimum,

package/src/intl.ts

@@ -0,0 +1,12 @@
+import * as Context from "effect-app/Context"
+import { accessCn, accessFn } from "effect-app/Context"
+import { type MakeIntlReturn } from "./makeIntl.js"
+
+type I18nShape = ReturnType<MakeIntlReturn<string>["useIntl"]>
+
+export class I18n extends Context.Opaque<I18n, I18nShape>()("I18n") {
+  static readonly locale = accessCn(this, "locale")
+  static readonly trans = accessFn(this, "trans")
+  static readonly formatMessage = accessFn(this, "formatMessage")
+  static readonly intl = accessCn(this, "intl")
+}

package/src/lib.ts

@@ -1,9 +1,10 @@
 import { type Pausable, useIntervalFn, type UseIntervalFnOptions } from "@vueuse/core"
-import { Cause, type Effect, pipe } from "effect-app"
-import { type Req } from "effect-app/client"
-import type { ClientForOptions, RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
+import type { Req } from "effect-app/client"
+import type { RequestHandlerWithInput } from "effect-app/client/clientFor"
+import type * as Effect from "effect-app/Effect"
+import * as Cause from "effect/Cause"
 import { isHttpClientError } from "effect/unstable/http/HttpClientError"
-import type { MaybeRefOrGetter } from "vue"
+import { isProxy, isReactive, isRef, type MaybeRefOrGetter, toRaw } from "vue"
 import { reportError } from "./errorReporter.js"
 
 export * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
@@ -31,15 +32,7 @@ const determineLevel = (cause: Cause.Cause<unknown>) => {
 export const reportRuntimeError = (cause: Cause.Cause<unknown>, extras?: Record<string, unknown>) =>
   reportRuntimeError_(cause, extras, determineLevel(cause))
 
-// $Project/$Configuration.Index
-// -> "$Project", "$Configuration", "Index"
-export const makeQueryKey = ({ id, options }: { id: string; options?: ClientForOptions }) =>
-  pipe(
-    id.split("/"),
-    (split) => split.filter((_) => !options || !options?.skipQueryKey?.includes(_)).map((_) => "$" + _)
-  )
-    .join(".")
-    .split(".")
+export { makeQueryKey } from "effect-app/client"
 
 export function pauseWhileProcessing(
   iv: Pausable,
@@ -75,13 +68,48 @@ export const mapHandler: {
     self: RequestHandlerWithInput<I, A, E, R, Request, Name>,
     map: (handler: (i: I) => Effect.Effect<A, E, R>) => (i: I) => Effect.Effect<A2, E2, R2>
   ): RequestHandlerWithInput<I, A2, E2, R2, Request, Name>
-  <E, A, R, E2, A2, R2, Request extends Req, Name extends string>(
-    self: RequestHandler<A, E, R, Request, Name>,
-    map: (handler: Effect.Effect<A, E, R>) => Effect.Effect<A2, E2, R2>
-  ): RequestHandler<A2, E2, R2, Request, Name>
 } = (self: any, map: any): any => ({
   ...self,
-  handler: typeof self.handler === "function"
-    ? (i: any) => map(self.handler as (i: any) => Effect.Effect<any, any, any>)(i)
-    : map(self.handler)
+  handler: (i: any) => map(self.handler as (i: any) => Effect.Effect<any, any, any>)(i)
 })
+
+export function deepToRaw<T>(sourceObj: T): T {
+  const objectIterator = (input: any): any => {
+    if (isRef(input)) {
+      return objectIterator(input.value)
+    }
+
+    const rawInput = isReactive(input) || isProxy(input)
+      ? toRaw(input)
+      : input
+
+    if (Array.isArray(rawInput)) {
+      return rawInput.map((item) => objectIterator(item))
+    }
+
+    if (rawInput instanceof Map) {
+      return new Map(
+        Array.from(rawInput.entries(), ([key, value]) => [objectIterator(key), objectIterator(value)])
+      )
+    }
+
+    if (rawInput instanceof Set) {
+      return new Set(Array.from(rawInput.values(), (value) => objectIterator(value)))
+    }
+
+    if (rawInput instanceof Date) {
+      return new Date(rawInput)
+    }
+
+    if (rawInput && typeof rawInput === "object") {
+      return Object.keys(rawInput).reduce((acc, key) => {
+        acc[key] = objectIterator(rawInput[key])
+        return acc
+      }, {} as Record<string, unknown>)
+    }
+
+    return rawInput
+  }
+
+  return objectIterator(sourceObj)
+}