@effect-app/vue-components 4.0.0-beta.31 → 4.0.0-beta.310

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

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type * as Effect from "effect-app/Effect"
+import * as S from "effect-app/Schema"
+import type * as Record from "effect/Record"
+import { getTransformationFrom } from "../../../utils"
+import type { FieldMeta, MetaRecord } from "./types"
+import { classifyAndWalkUnion, leafMetaForAst, type ParentMeta, type WalkerContext, walkStruct } from "./walker"
+
+export type FilterItems = {
+  items: readonly [string, ...string[]]
+  message:
+    | string
+    | Effect.Effect<string>
+    | { readonly message: string | Effect.Effect<string> }
+}
+
+export type CreateMeta =
+  & {
+    parent?: string
+    meta?: Record<string, any>
+    nullableOrUndefined?: false | "undefined" | "null"
+  }
+  & (
+    | {
+      propertySignatures: readonly S.AST.PropertySignature[]
+      property?: never
+    }
+    | {
+      propertySignatures?: never
+      property: S.AST.AST
+    }
+  )
+
+export const unwrapDeclaration = (property: S.AST.AST): S.AST.AST => {
+  let current = getTransformationFrom(property)
+
+  while (S.AST.isDeclaration(current) && current.typeParameters.length > 0) {
+    current = getTransformationFrom(current.typeParameters[0])
+  }
+
+  return current
+}
+
+export const isNullableOrUndefined = (property: false | S.AST.AST | undefined) => {
+  if (!property || !S.AST.isUnion(property)) return false
+  if (property.types.find((_) => S.AST.isUndefined(_))) {
+    return "undefined"
+  }
+  if (property.types.find((_) => S.AST.isNull(_))) return "null"
+  return false
+}
+
+export const createMeta = <T = any>(
+  { meta = {}, parent = "", property, propertySignatures }: CreateMeta,
+  acc: Partial<MetaRecord<T>> = {}
+): MetaRecord<T> | FieldMeta => {
+  const ctx: WalkerContext<T> = { acc, unionMeta: {} }
+
+  if (propertySignatures) {
+    const parentMeta: ParentMeta = {
+      required: meta.required !== false,
+      nullableOrUndefined: meta.nullableOrUndefined ?? false
+    }
+    walkStruct(propertySignatures, parent, parentMeta, ctx)
+    return acc
+  }
+
+  if (property) {
+    const nullableOrUndefined = isNullableOrUndefined(property)
+    const unwrapped = unwrapDeclaration(property)
+    const required = !Object.hasOwnProperty.call(meta, "required")
+      ? !nullableOrUndefined
+      : (meta.required as boolean)
+
+    const parentMeta: ParentMeta = {
+      required,
+      nullableOrUndefined: (meta.nullableOrUndefined ?? nullableOrUndefined) as false | "null" | "undefined"
+    }
+
+    if (S.AST.isObjects(unwrapped)) {
+      walkStruct(unwrapped.propertySignatures, parent, parentMeta, ctx)
+      return acc
+    }
+
+    if (S.AST.isUnion(unwrapped)) {
+      // For property-mode, return a FieldMeta by running through classifyAndWalkUnion
+      // and then pulling out the result at `parent` key
+      const leafCtx: WalkerContext<T> = { acc: {}, unionMeta: {} }
+      classifyAndWalkUnion(unwrapped, parent, parentMeta, leafCtx)
+      const result = (leafCtx.acc as any)[parent]
+      if (result) return result as FieldMeta
+    }
+
+    return leafMetaForAst(unwrapped, parentMeta)
+  }
+
+  return acc
+}
+
+export const metadataFromAst = <From, To>(
+  schema: S.Codec<To, From>
+): {
+  meta: MetaRecord<To>
+  defaultValues: Record<string, any>
+  unionMeta: Record<string, MetaRecord<To>>
+} => {
+  const ast = unwrapDeclaration(schema.ast)
+  const newMeta: Partial<MetaRecord<To>> = {}
+  const defaultValues: Record<string, any> = {}
+  const unionMeta: Record<string, MetaRecord<To>> = {}
+
+  const ctx: WalkerContext<To> = { acc: newMeta, unionMeta }
+
+  if (S.AST.isUnion(ast)) {
+    // Root-level discriminated union
+    classifyAndWalkUnion(ast, "", { required: true, nullableOrUndefined: false }, ctx)
+
+    return { meta: newMeta, defaultValues, unionMeta }
+  }
+
+  if (S.AST.isObjects(ast)) {
+    walkStruct(ast.propertySignatures, "", { required: true, nullableOrUndefined: false }, ctx)
+
+    return { meta: newMeta, defaultValues, unionMeta }
+  }
+
+  return { meta: newMeta, defaultValues, unionMeta }
+}
+
+export const generateMetaFromSchema = <From, To>(
+  schema: S.Codec<To, From>
+): {
+  schema: S.Codec<To, From>
+  meta: MetaRecord<To>
+  unionMeta: Record<string, MetaRecord<To>>
+} => {
+  const { meta, unionMeta } = metadataFromAst(schema)
+
+  return { schema, meta, unionMeta }
+}

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

@@ -0,0 +1,262 @@
+/* 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 {
+    // oxlint-disable-next-line typescript/no-unnecessary-type-assertion -- vue-tsc needs the decoded value narrowed at this boundary
+    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
+}