@effect-app/vue-components 4.0.0-beta.29 → 4.0.0-beta.290

package/src/components/OmegaForm/meta/defaults.ts

@@ -0,0 +1,261 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import { isNullableOrUndefined, unwrapDeclaration } from "./createMeta"
+
+const extractDefaultFromLink = (link: any): unknown | undefined => {
+  if (!link?.transformation?.decode?.run) return undefined
+  try {
+    const result = Effect.runSync(link.transformation.decode.run(Option.none())) as Option.Option<unknown>
+    return Option.isSome(result) ? result.value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const getDefaultFromAst = (property: S.AST.AST) => {
+  // 1. Check withConstructorDefault (stored in context.defaultValue)
+  const constructorLink = property.context?.defaultValue?.[0]
+  const constructorDefault = extractDefaultFromLink(constructorLink)
+  if (constructorDefault !== undefined) return constructorDefault
+
+  // 2. Check withDecodingDefault (stored in encoding)
+  const encodingLink = property.encoding?.[0]
+  if (encodingLink && property.context?.isOptional) {
+    return extractDefaultFromLink(encodingLink)
+  }
+
+  return undefined
+}
+
+type SchemaWithMembers = {
+  members: readonly S.Schema<any>[]
+}
+
+type UnknownRecord = Record<string, unknown>
+
+function hasMembers(schema: any): schema is SchemaWithMembers {
+  return schema && "members" in schema && Array.isArray(schema.members)
+}
+
+const isRecord = (value: unknown): value is UnknownRecord =>
+  value !== null && typeof value === "object" && !Array.isArray(value)
+
+const isNullishAst = (ast: S.AST.AST) => S.AST.isNull(ast) || S.AST.isUndefined(ast)
+
+const unionMembers = (ast: S.AST.AST): readonly S.AST.AST[] => {
+  const resolved = unwrapDeclaration(ast)
+  return S.AST.isUnion(resolved)
+    ? resolved.types.flatMap(unionMembers)
+    : [resolved]
+}
+
+const literalValue = (ast: S.AST.AST): unknown => {
+  const resolved = unwrapDeclaration(ast)
+  if (S.AST.isLiteral(resolved)) return resolved.literal
+  if (S.AST.isUnion(resolved) && resolved.types.length === 1) {
+    return literalValue(resolved.types[0])
+  }
+}
+
+const findTaggedObjectMember = (
+  members: readonly S.AST.Objects[],
+  value: unknown
+): S.AST.Objects | undefined => {
+  if (!isRecord(value) || value._tag === undefined) return undefined
+
+  return members.find((member) => {
+    const tagProp = member.propertySignatures.find((prop) => prop.name.toString() === "_tag")
+    return tagProp ? literalValue(tagProp.type) === value._tag : false
+  })
+}
+
+// Internal implementation with WeakSet tracking
+export const defaultsValueFromSchema = (
+  schema: S.Schema<any>,
+  record: Record<string, any> = {}
+): any => {
+  const ast = schema.ast
+  const defaultValue = getDefaultFromAst(ast)
+
+  if (defaultValue !== undefined) {
+    return defaultValue
+  }
+
+  if (isNullableOrUndefined(schema.ast) === "null") {
+    return null
+  }
+  if (isNullableOrUndefined(schema.ast) === "undefined") {
+    return undefined
+  }
+
+  // Handle structs via AST (covers plain structs, transformed schemas like decodeTo, Class, etc.)
+  const objectsAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? unwrapDeclaration(ast)
+    : undefined
+  if (objectsAst && S.AST.isObjects(objectsAst)) {
+    const result: Record<string, any> = {}
+
+    for (const prop of objectsAst.propertySignatures) {
+      const key = prop.name.toString()
+      const propType = prop.type
+
+      const propDefault = getDefaultFromAst(propType)
+      if (propDefault !== undefined) {
+        result[key] = propDefault
+        continue
+      }
+
+      const propSchema = S.make<any>(propType)
+      const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
+
+      if (propValue !== undefined) {
+        result[key] = propValue
+      } else if (isNullableOrUndefined(propType) === "undefined") {
+        result[key] = undefined
+      }
+    }
+
+    return { ...result, ...record }
+  }
+
+  // Handle unions via AST or schema-level .members
+  const unionTypes = S.AST.isUnion(ast)
+    ? ast.types
+    : hasMembers(schema)
+    ? schema.members.map((m) => m.ast)
+    : undefined
+  if (unionTypes) {
+    const mergedFields: Record<string, { ast: S.AST.AST }> = {}
+
+    for (const memberAstRaw of unionTypes) {
+      const memberAst = unwrapDeclaration(memberAstRaw)
+      if (!S.AST.isObjects(memberAst)) continue
+
+      for (const prop of memberAst.propertySignatures) {
+        const key = prop.name.toString()
+        const fieldDefault = getDefaultFromAst(prop.type)
+        const existingDefault = mergedFields[key] ? getDefaultFromAst(mergedFields[key].ast) : undefined
+
+        if (!mergedFields[key] || (fieldDefault !== undefined && existingDefault === undefined)) {
+          mergedFields[key] = { ast: prop.type }
+        }
+      }
+    }
+
+    if (Object.keys(mergedFields).length === 0) {
+      return Object.keys(record).length > 0 ? record : undefined
+    }
+
+    return Object.entries(mergedFields).reduce((acc, [key, { ast: propAst }]) => {
+      acc[key] = defaultsValueFromSchema(S.make(propAst), record[key] || {})
+      return acc
+    }, record)
+  }
+
+  if (Object.keys(record).length === 0) {
+    if (S.AST.isString(ast)) {
+      return ""
+    }
+
+    if (S.AST.isBoolean(ast)) {
+      return false
+    }
+  }
+}
+
+/**
+ * Deep-fills a partial form value with schema defaults for any nullable
+ * struct that has **materialised**.
+ *
+ * A nullable struct (`S.NullOr(S.Struct(...))`) left `null` stays `null`, but
+ * once it materialises — e.g. the user filled a single child — its untouched
+ * children are filled with their schema default (or `null` when nullable).
+ * Without this, strict `S.NullOr(...)` children reject the leftover
+ * `undefined` with a spurious "field must not be empty" error.
+ *
+ * Only children of a struct reached *through a nullable union* are filled;
+ * the always-present root struct keeps whatever fields it already has, so the
+ * form's own default-value priority is left untouched.
+ *
+ * Reference-preserving: returns `value` unchanged (same reference) when there
+ * is nothing to fill, so callers can detect a no-op with `===` and the result
+ * is idempotent (`fill(fill(v)) === fill(v)`).
+ */
+export const fillNestedDefaults = (
+  ast: S.AST.AST,
+  value: unknown,
+  fillMissing = false
+): unknown => {
+  const resolved = unwrapDeclaration(ast)
+
+  switch (resolved._tag) {
+    case "Union": {
+      if (value === null || value === undefined) return value
+      const members = unionMembers(resolved)
+      const objectMembers = members.filter(S.AST.isObjects)
+      if (objectMembers.length === 0) return value
+
+      const hasNullishMember = members.some(isNullishAst)
+      const taggedMember = findTaggedObjectMember(objectMembers, value)
+      if (taggedMember) {
+        return fillNestedDefaults(taggedMember, value, fillMissing || hasNullishMember)
+      }
+
+      if (hasNullishMember && objectMembers.length === 1) {
+        return fillNestedDefaults(objectMembers[0], value, true)
+      }
+
+      return value
+    }
+
+    case "Arrays": {
+      if (!Array.isArray(value)) return value
+      const element = resolved.rest[0]
+      if (!element) return value
+      let changed = false
+      const next = value.map((item) => {
+        const filled = fillNestedDefaults(element, item, fillMissing)
+        if (filled !== item) changed = true
+        return filled
+      })
+      return changed ? next : value
+    }
+
+    case "Objects": {
+      if (!isRecord(value)) return value
+      let result: UnknownRecord = value
+      let changed = false
+      const set = (key: string, next: unknown) => {
+        if (!changed) {
+          result = { ...value }
+          changed = true
+        }
+        result[key] = next
+      }
+      for (const prop of resolved.propertySignatures) {
+        const key = prop.name.toString()
+        const current = value[key]
+        if (current !== undefined) {
+          const filled = fillNestedDefaults(prop.type, current, fillMissing)
+          if (filled !== current) set(key, filled)
+          continue
+        }
+        if (!fillMissing || prop.type.context?.isOptional === true) continue
+        const propDefault = getDefaultFromAst(prop.type)
+        if (propDefault !== undefined) {
+          set(key, propDefault)
+        } else if (isNullableOrUndefined(prop.type) === "null") {
+          set(key, null)
+        }
+      }
+      return result
+    }
+
+    default:
+      return value
+  }
+}

package/src/components/OmegaForm/meta/redacted.ts

@@ -0,0 +1,66 @@
+import * as S from "effect-app/Schema"
+
+/*
+ * Checks if an AST node is a S.Redacted Declaration without encoding.
+ * These need to be swapped to S.RedactedFromValue for form usage
+ * because S.Redacted expects Redacted objects, not plain strings.
+ */
+const isRedactedWithoutEncoding = (ast: S.AST.AST): boolean =>
+  S.AST.isDeclaration(ast)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Effect Schema AST annotations are loosely typed
+  && (ast.annotations as any)?.typeConstructor?._tag === "effect/Redacted"
+  && !ast.encoding
+
+/*
+ * Creates a form-compatible schema by replacing S.Redacted(X) with
+ * S.RedactedFromValue(X). S.Redacted is a Declaration that expects
+ * Redacted<A> on both encoded and type sides, so form inputs (which
+ * produce plain strings) fail validation. S.RedactedFromValue accepts
+ * plain values on the encoded side and wraps them in Redacted on decode.
+ */
+export const toFormSchema = <From, To>(
+  schema: S.Codec<To, From>
+): S.Codec<To, From> => {
+  const ast = schema.ast
+  const objAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? S.AST.toEncoded(ast)
+    : null
+
+  if (!objAst || !("propertySignatures" in objAst)) return schema
+
+  let hasRedacted = false
+  const props: Record<string, S.Struct.Fields[string]> = {}
+
+  for (const p of objAst.propertySignatures) {
+    if (isRedactedWithoutEncoding(p.type)) {
+      hasRedacted = true
+      const innerSchema = S.make((p.type as S.AST.Declaration).typeParameters[0])
+      props[p.name as string] = S.RedactedFromValue(innerSchema)
+    } else if (S.AST.isUnion(p.type)) {
+      const types = p.type.types
+      const redactedType = types.find(isRedactedWithoutEncoding)
+      if (redactedType) {
+        hasRedacted = true
+        const innerSchema = S.make((redactedType as S.AST.Declaration).typeParameters[0])
+        const hasNull = types.some(S.AST.isNull)
+        const hasUndefined = types.some(S.AST.isUndefined)
+        const base = S.RedactedFromValue(innerSchema)
+        props[p.name as string] = hasNull && hasUndefined
+          ? S.NullishOr(base)
+          : hasNull
+          ? S.NullOr(base)
+          : hasUndefined
+          ? S.UndefinedOr(base)
+          : base
+      } else {
+        props[p.name as string] = S.make(p.type)
+      }
+    } else {
+      props[p.name as string] = S.make(p.type)
+    }
+  }
+
+  return hasRedacted ? S.Struct(props) as unknown as S.Codec<To, From> : schema
+}

package/src/components/OmegaForm/meta/types.ts

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { DeepKeys } from "@tanstack/vue-form"
+import type * as S from "effect-app/Schema"
+import type { Redacted } from "effect/Redacted"
+
+// Recursively replace Redacted<A> with its inner type so DeepKeys treats it as a leaf
+type StripRedacted<T> = T extends Redacted<any> ? string
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<StripRedacted<U>>
+  : T extends Record<string, any> ? { [K in keyof T]: StripRedacted<T[K]> }
+  : T
+
+export type NestedKeyOf<T> = DeepKeys<StripRedacted<T>>
+
+// Field metadata type definitions
+export type BaseFieldMeta = {
+  required: boolean
+  nullableOrUndefined?: false | "undefined" | "null"
+  /**
+   * True when the schema property is `S.optionalKey` (AST
+   * `context.isOptional`) — i.e. the key should be ABSENT from the submitted
+   * object when empty, not present with `undefined`. Distinct from
+   * `required: false`, which may also mean "empty string is valid" for
+   * unconstrained `S.String` fields.
+   */
+  isOptionalKey?: boolean
+}
+
+export type StringFieldMeta = BaseFieldMeta & {
+  type: "string"
+  maxLength?: number
+  minLength?: number
+  format?: string
+}
+
+export type NumberFieldMeta = BaseFieldMeta & {
+  type: "number"
+  minimum?: number
+  maximum?: number
+  exclusiveMinimum?: number
+  exclusiveMaximum?: number
+  refinement?: "int"
+}
+
+export type SelectFieldMeta = BaseFieldMeta & {
+  type: "select"
+  members: any[] // TODO: should be non empty array?
+}
+
+export type MultipleFieldMeta = BaseFieldMeta & {
+  type: "multiple"
+  members: any[] // TODO: should be non empty array?
+  rest: readonly S.AST.AST[]
+}
+
+export type BooleanFieldMeta = BaseFieldMeta & {
+  type: "boolean"
+}
+
+export type DateFieldMeta = BaseFieldMeta & {
+  type: "date"
+}
+
+export type UnknownFieldMeta = BaseFieldMeta & {
+  type: "unknown"
+}
+
+export type FieldMeta =
+  | StringFieldMeta
+  | NumberFieldMeta
+  | SelectFieldMeta
+  | MultipleFieldMeta
+  | BooleanFieldMeta
+  | DateFieldMeta
+  | UnknownFieldMeta
+
+export type MetaRecord<T = string> = {
+  [K in NestedKeyOf<T>]?: FieldMeta
+}

package/src/components/OmegaForm/meta/walker.ts

@@ -0,0 +1,248 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- AST walker interops with Effect Schema generics */
+/* eslint-disable @typescript-eslint/no-use-before-define -- mutual recursion between walk and helpers (handleStruct/handleUnion/etc.) */
+import * as S from "effect-app/Schema"
+import { getFieldMetadataFromAst } from "./checks"
+import { isNullableOrUndefined, unwrapDeclaration } from "./createMeta"
+import type { FieldMeta, MetaRecord, NestedKeyOf, SelectFieldMeta } from "./types"
+
+const isNullishType = (property: S.AST.AST) => S.AST.isUndefined(property) || S.AST.isNull(property)
+
+// TODO: remove after manual _tag deprecation — S.Struct({ _tag: S.Literal("X") }) wraps as Union([Literal("X")])
+const unwrapSingleLiteralUnion = (ast: S.AST.AST): S.AST.AST =>
+  S.AST.isUnion(ast) && ast.types.length === 1 && S.AST.isLiteral(ast.types[0])
+    ? ast.types[0]
+    : ast
+
+const unwrapNestedUnions = (types: readonly S.AST.AST[]): readonly S.AST.AST[] =>
+  types.flatMap((type) => S.AST.isUnion(type) ? unwrapNestedUnions(type.types) : [type])
+
+export type WalkerContext<T> = {
+  acc: Partial<MetaRecord<T>>
+  unionMeta: Record<string, MetaRecord<T>>
+}
+
+export type ParentMeta = {
+  required: boolean
+  nullableOrUndefined: false | "null" | "undefined"
+  /** Set when iterating the members of a nullable discriminated union */
+  isNullableDiscriminatedUnion?: boolean
+  /** Set when this property was declared with S.optionalKey */
+  isOptionalKey?: boolean
+}
+
+export const leafMetaForAst = (
+  ast: S.AST.AST,
+  parentMeta: ParentMeta
+): FieldMeta => {
+  const { nullableOrUndefined, required } = parentMeta
+
+  if (S.AST.isArrays(ast)) {
+    return {
+      required,
+      nullableOrUndefined,
+      type: "multiple",
+      members: ast.elements,
+      rest: ast.rest
+    } as FieldMeta
+  }
+
+  if (S.AST.isLiteral(ast)) {
+    return {
+      required,
+      nullableOrUndefined,
+      type: "select",
+      members: [ast.literal]
+    } as FieldMeta
+  }
+
+  return {
+    ...getFieldMetadataFromAst(ast),
+    required,
+    nullableOrUndefined
+  } as FieldMeta
+}
+
+export const walkStruct = <T>(
+  propertySignatures: readonly S.AST.PropertySignature[],
+  parent: string,
+  parentMeta: ParentMeta,
+  ctx: WalkerContext<T>
+): void => {
+  for (const p of propertySignatures) {
+    const key = parent ? `${parent}.${p.name.toString()}` : p.name.toString()
+    const nullableOrUndefined = isNullableOrUndefined(p.type)
+    const isOptionalKey = (p.type as any).context?.isOptional === true
+
+    let isRequired: boolean
+    if (parentMeta.isNullableDiscriminatedUnion && p.name.toString() === "_tag") {
+      isRequired = false
+    } else if (!parentMeta.required) {
+      isRequired = false
+    } else if (isOptionalKey) {
+      isRequired = false
+    } else {
+      isRequired = !nullableOrUndefined
+    }
+
+    walk(
+      p.type,
+      key,
+      { required: isRequired, nullableOrUndefined, isOptionalKey },
+      ctx
+    )
+  }
+}
+
+export const classifyAndWalkUnion = <T>(
+  unionAst: S.AST.Union,
+  key: string,
+  parentMeta: ParentMeta,
+  ctx: WalkerContext<T>
+): void => {
+  const { acc } = ctx
+  const unwrappedTypes = unwrapNestedUnions(unionAst.types).map(unwrapDeclaration)
+  const nonNullTypes = unwrappedTypes.filter((t) => !isNullishType(t))
+
+  // Boolean literal shortcut (single-value union wrapping a boolean literal)
+  if (nonNullTypes.length === 1 && S.AST.isLiteral(nonNullTypes[0]) && typeof nonNullTypes[0].literal === "boolean") {
+    acc[key as NestedKeyOf<T>] = leafMetaForAst(nonNullTypes[0], parentMeta)
+    return
+  }
+
+  if (nonNullTypes.some(S.AST.isObjects)) {
+    const isNullableDiscriminatedUnion = !!parentMeta.nullableOrUndefined && nonNullTypes.length > 1
+
+    // Mixed union: also create a parent leaf entry from the first non-struct member
+    if (!parentMeta.nullableOrUndefined && key) {
+      const firstNonStruct = nonNullTypes.find((t) => !S.AST.isObjects(t))
+      if (firstNonStruct) {
+        acc[key as NestedKeyOf<T>] = leafMetaForAst(firstNonStruct, parentMeta)
+      }
+    }
+
+    const discriminatorValues: any[] = []
+    const branchParentMeta: ParentMeta = isNullableDiscriminatedUnion
+      ? { required: true, nullableOrUndefined: false, isNullableDiscriminatedUnion: true }
+      : { required: true, nullableOrUndefined: false }
+
+    for (const memberType of nonNullTypes) {
+      if (!S.AST.isObjects(memberType)) continue
+
+      const tagProp = memberType.propertySignatures.find((p) => p.name.toString() === "_tag")
+      const resolvedTagType = tagProp ? unwrapSingleLiteralUnion(tagProp.type) : null
+      let tagValue: string | null = null
+
+      if (resolvedTagType && S.AST.isLiteral(resolvedTagType)) {
+        tagValue = resolvedTagType.literal as string
+        if (!discriminatorValues.includes(tagValue)) discriminatorValues.push(tagValue)
+      }
+
+      const branchCtx: WalkerContext<T> = { acc: {}, unionMeta: ctx.unionMeta }
+      walkStruct(memberType.propertySignatures, key, branchParentMeta, branchCtx)
+
+      if (tagValue) {
+        const existing = ctx.unionMeta[tagValue]
+        if (existing) Object.assign(existing, branchCtx.acc as MetaRecord<T>)
+        else ctx.unionMeta[tagValue] = branchCtx.acc as MetaRecord<T>
+      }
+
+      for (const [metaKey, metaValue] of Object.entries(branchCtx.acc)) {
+        const existing = acc[metaKey as NestedKeyOf<T>]
+        if (existing && existing.type === "select" && (metaValue as any)?.type === "select") {
+          existing.members = [
+            ...existing.members,
+            ...(metaValue as SelectFieldMeta).members.filter((m: any) => !existing.members.includes(m))
+          ]
+        } else {
+          acc[metaKey as NestedKeyOf<T>] = metaValue as FieldMeta
+        }
+      }
+    }
+
+    if (discriminatorValues.length > 0) {
+      const tagKey = key ? `${key}._tag` : "_tag"
+      const existing = acc[tagKey as NestedKeyOf<T>]
+      if (existing && existing.type === "select") {
+        for (const v of discriminatorValues) {
+          if (!existing.members.includes(v)) existing.members.push(v)
+        }
+      } else {
+        acc[tagKey as NestedKeyOf<T>] = {
+          type: "select",
+          members: discriminatorValues,
+          required: !isNullableDiscriminatedUnion
+        } as FieldMeta
+      }
+    }
+    return
+  }
+
+  const ast = nonNullTypes.find(S.AST.isArrays)
+  if (ast) {
+    walk(ast, key, parentMeta, ctx)
+    return
+  }
+
+  // Literal / primitive union (e.g. legacy _tag pattern)
+  const resolvedTypes = unwrappedTypes.map(unwrapSingleLiteralUnion)
+  if (resolvedTypes.every((_) => isNullishType(_) || S.AST.isLiteral(_))) {
+    const { isOptionalKey, nullableOrUndefined, required } = parentMeta
+    const leaf: FieldMeta = {
+      required,
+      nullableOrUndefined,
+      type: "select",
+      members: resolvedTypes.filter(S.AST.isLiteral).map((t) => t.literal)
+    } as FieldMeta
+    if (isOptionalKey) leaf.isOptionalKey = true
+    acc[key as NestedKeyOf<T>] = leaf
+    return
+  }
+
+  // Fallback: recurse into first non-null type
+  const nonNullType = nonNullTypes[0]
+  if (nonNullType) walk(nonNullType, key, parentMeta, ctx)
+}
+
+export const walk = <T>(
+  ast: S.AST.AST,
+  key: string,
+  parentMeta: ParentMeta,
+  ctx: WalkerContext<T>
+): void => {
+  ast = unwrapDeclaration(ast)
+  const { acc } = ctx
+
+  if (S.AST.isObjects(ast)) {
+    walkStruct(ast.propertySignatures, key, parentMeta, ctx)
+    return
+  }
+
+  if (S.AST.isUnion(ast)) {
+    classifyAndWalkUnion(ast, key, parentMeta, ctx)
+    return
+  }
+
+  if (S.AST.isArrays(ast)) {
+    const restElement = ast.rest.length > 0 ? unwrapDeclaration(ast.rest[0]) : null
+    if (restElement && S.AST.isObjects(restElement)) {
+      // Array-of-struct: skip creating a meta entry for the array itself,
+      // recurse into the element struct's properties instead
+      walkStruct(restElement.propertySignatures, key, { required: true, nullableOrUndefined: false }, ctx)
+      return
+    }
+
+    // Primitive or tuple array
+    acc[key as NestedKeyOf<T>] = leafMetaForAst(ast, parentMeta)
+    return
+  }
+
+  // Leaf primitive / literal / unknown
+  const { isOptionalKey, nullableOrUndefined, required } = parentMeta
+  const adjusted: ParentMeta = {
+    required: required && (!S.AST.isString(ast) || !!getFieldMetadataFromAst(ast).minLength),
+    nullableOrUndefined
+  }
+  const leaf = leafMetaForAst(ast, adjusted)
+  if (isOptionalKey) leaf.isOptionalKey = true
+  acc[key as NestedKeyOf<T>] = leaf
+}